jbx 2.3.0 → 2.5.0

package/dist/index.cjs

@@ -0,0 +1,3001 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var react = {exports: {}};
+
+var react_production_min = {};
+
+/**
+ * @license React
+ * react.production.min.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 _typeof$1 = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+var hasRequiredReact_production_min;
+function requireReact_production_min() {
+    var A = function A(a) {
+        if (null === a || "object" !== typeof a) return null;
+        a = z && a[z] || a["@@iterator"];
+        return "function" === typeof a ? a : null;
+    };
+    var E = function E(a, b, e) {
+        this.props = a;
+        this.context = b;
+        this.refs = D;
+        this.updater = e || B;
+    };
+    var F = function F() {};
+    var G = function G(a, b, e) {
+        this.props = a;
+        this.context = b;
+        this.refs = D;
+        this.updater = e || B;
+    };
+    var M = function M(a, b, e) {
+        var d, c = {}, k = null, h = null;
+        if (null != b) for(d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b)J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+        var g = arguments.length - 2;
+        if (1 === g) c.children = e;
+        else if (1 < g) {
+            for(var f = Array(g), m = 0; m < g; m++)f[m] = arguments[m + 2];
+            c.children = f;
+        }
+        if (a && a.defaultProps) for(d in g = a.defaultProps, g)void 0 === c[d] && (c[d] = g[d]);
+        return {
+            $$typeof: l,
+            type: a,
+            key: k,
+            ref: h,
+            props: c,
+            _owner: K.current
+        };
+    };
+    var N = function N(a, b) {
+        return {
+            $$typeof: l,
+            type: a.type,
+            key: b,
+            ref: a.ref,
+            props: a.props,
+            _owner: a._owner
+        };
+    };
+    var O = function O(a) {
+        return "object" === typeof a && null !== a && a.$$typeof === l;
+    };
+    var escape = function escape(a) {
+        var b = {
+            "=": "=0",
+            ":": "=2"
+        };
+        return "$" + a.replace(/[=:]/g, function(a) {
+            return b[a];
+        });
+    };
+    var Q = function Q(a, b) {
+        return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+    };
+    var S = function S(a, b, e) {
+        if (null == a) return a;
+        var d = [], c = 0;
+        R(a, d, "", "", function(a) {
+            return b.call(e, a, c++);
+        });
+        return d;
+    };
+    var T = function T(a) {
+        if (-1 === a._status) {
+            var b = a._result;
+            b = b();
+            b.then(function(b) {
+                if (0 === a._status || -1 === a._status) a._status = 1, a._result = b;
+            }, function(b) {
+                if (0 === a._status || -1 === a._status) a._status = 2, a._result = b;
+            });
+            -1 === a._status && (a._status = 0, a._result = b);
+        }
+        if (1 === a._status) return a._result.default;
+        throw a._result;
+    };
+    if (hasRequiredReact_production_min) return react_production_min;
+    hasRequiredReact_production_min = 1;
+    var l = Symbol.for("react.element"), n = Symbol.for("react.portal"), p = Symbol.for("react.fragment"), q = Symbol.for("react.strict_mode"), r = Symbol.for("react.profiler"), t = Symbol.for("react.provider"), u = Symbol.for("react.context"), v = Symbol.for("react.forward_ref"), w = Symbol.for("react.suspense"), x = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), z = Symbol.iterator;
+    var B = {
+        isMounted: function isMounted() {
+            return !1;
+        },
+        enqueueForceUpdate: function enqueueForceUpdate() {},
+        enqueueReplaceState: function enqueueReplaceState() {},
+        enqueueSetState: function enqueueSetState() {}
+    }, C = Object.assign, D = {};
+    E.prototype.isReactComponent = {};
+    E.prototype.setState = function(a, b) {
+        if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+        this.updater.enqueueSetState(this, a, b, "setState");
+    };
+    E.prototype.forceUpdate = function(a) {
+        this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+    };
+    F.prototype = E.prototype;
+    var H = G.prototype = new F;
+    H.constructor = G;
+    C(H, E.prototype);
+    H.isPureReactComponent = !0;
+    var I = Array.isArray, J = Object.prototype.hasOwnProperty, K = {
+        current: null
+    }, L = {
+        key: !0,
+        ref: !0,
+        __self: !0,
+        __source: !0
+    };
+    var P = /\/+/g;
+    function R(a, b, e, d, c) {
+        var k = typeof a === "undefined" ? "undefined" : _typeof$1(a);
+        if ("undefined" === k || "boolean" === k) a = null;
+        var h = !1;
+        if (null === a) h = !0;
+        else switch(k){
+            case "string":
+            case "number":
+                h = !0;
+                break;
+            case "object":
+                switch(a.$$typeof){
+                    case l:
+                    case n:
+                        h = !0;
+                }
+        }
+        if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function(a) {
+            return a;
+        })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+        h = 0;
+        d = "" === d ? "." : d + ":";
+        if (I(a)) for(var g = 0; g < a.length; g++){
+            k = a[g];
+            var f = d + Q(k, g);
+            h += R(k, b, e, f, c);
+        }
+        else if (f = A(a), "function" === typeof f) for(a = f.call(a), g = 0; !(k = a.next()).done;)k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
+        else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+        return h;
+    }
+    var U = {
+        current: null
+    }, V = {
+        transition: null
+    }, W = {
+        ReactCurrentDispatcher: U,
+        ReactCurrentBatchConfig: V,
+        ReactCurrentOwner: K
+    };
+    react_production_min.Children = {
+        map: S,
+        forEach: function forEach(a, b, e) {
+            S(a, function() {
+                b.apply(this, arguments);
+            }, e);
+        },
+        count: function count(a) {
+            var b = 0;
+            S(a, function() {
+                b++;
+            });
+            return b;
+        },
+        toArray: function toArray(a) {
+            return S(a, function(a) {
+                return a;
+            }) || [];
+        },
+        only: function only(a) {
+            if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+            return a;
+        }
+    };
+    react_production_min.Component = E;
+    react_production_min.Fragment = p;
+    react_production_min.Profiler = r;
+    react_production_min.PureComponent = G;
+    react_production_min.StrictMode = q;
+    react_production_min.Suspense = w;
+    react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+    react_production_min.cloneElement = function(a, b, e) {
+        if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+        var d = C({}, a.props), c = a.key, k = a.ref, h = a._owner;
+        if (null != b) {
+            void 0 !== b.ref && (k = b.ref, h = K.current);
+            void 0 !== b.key && (c = "" + b.key);
+            if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+            for(f in b)J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+        }
+        var f = arguments.length - 2;
+        if (1 === f) d.children = e;
+        else if (1 < f) {
+            g = Array(f);
+            for(var m = 0; m < f; m++)g[m] = arguments[m + 2];
+            d.children = g;
+        }
+        return {
+            $$typeof: l,
+            type: a.type,
+            key: c,
+            ref: k,
+            props: d,
+            _owner: h
+        };
+    };
+    react_production_min.createContext = function(a) {
+        a = {
+            $$typeof: u,
+            _currentValue: a,
+            _currentValue2: a,
+            _threadCount: 0,
+            Provider: null,
+            Consumer: null,
+            _defaultValue: null,
+            _globalName: null
+        };
+        a.Provider = {
+            $$typeof: t,
+            _context: a
+        };
+        return a.Consumer = a;
+    };
+    react_production_min.createElement = M;
+    react_production_min.createFactory = function(a) {
+        var b = M.bind(null, a);
+        b.type = a;
+        return b;
+    };
+    react_production_min.createRef = function() {
+        return {
+            current: null
+        };
+    };
+    react_production_min.forwardRef = function(a) {
+        return {
+            $$typeof: v,
+            render: a
+        };
+    };
+    react_production_min.isValidElement = O;
+    react_production_min.lazy = function(a) {
+        return {
+            $$typeof: y,
+            _payload: {
+                _status: -1,
+                _result: a
+            },
+            _init: T
+        };
+    };
+    react_production_min.memo = function(a, b) {
+        return {
+            $$typeof: x,
+            type: a,
+            compare: void 0 === b ? null : b
+        };
+    };
+    react_production_min.startTransition = function(a) {
+        var b = V.transition;
+        V.transition = {};
+        try {
+            a();
+        } finally{
+            V.transition = b;
+        }
+    };
+    react_production_min.unstable_act = function() {
+        throw Error("act(...) is not supported in production builds of React.");
+    };
+    react_production_min.useCallback = function(a, b) {
+        return U.current.useCallback(a, b);
+    };
+    react_production_min.useContext = function(a) {
+        return U.current.useContext(a);
+    };
+    react_production_min.useDebugValue = function() {};
+    react_production_min.useDeferredValue = function(a) {
+        return U.current.useDeferredValue(a);
+    };
+    react_production_min.useEffect = function(a, b) {
+        return U.current.useEffect(a, b);
+    };
+    react_production_min.useId = function() {
+        return U.current.useId();
+    };
+    react_production_min.useImperativeHandle = function(a, b, e) {
+        return U.current.useImperativeHandle(a, b, e);
+    };
+    react_production_min.useInsertionEffect = function(a, b) {
+        return U.current.useInsertionEffect(a, b);
+    };
+    react_production_min.useLayoutEffect = function(a, b) {
+        return U.current.useLayoutEffect(a, b);
+    };
+    react_production_min.useMemo = function(a, b) {
+        return U.current.useMemo(a, b);
+    };
+    react_production_min.useReducer = function(a, b, e) {
+        return U.current.useReducer(a, b, e);
+    };
+    react_production_min.useRef = function(a) {
+        return U.current.useRef(a);
+    };
+    react_production_min.useState = function(a) {
+        return U.current.useState(a);
+    };
+    react_production_min.useSyncExternalStore = function(a, b, e) {
+        return U.current.useSyncExternalStore(a, b, e);
+    };
+    react_production_min.useTransition = function() {
+        return U.current.useTransition();
+    };
+    react_production_min.version = "18.2.0";
+    return react_production_min;
+}
+
+var react_development = {exports: {}};
+
+/**
+ * @license React
+ * react.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.
+ */ function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+var hasRequiredReact_development;
+function requireReact_development() {
+    if (hasRequiredReact_development) return react_development.exports;
+    hasRequiredReact_development = 1;
+    (function(module, exports) {
+        if (process.env.NODE_ENV !== "production") {
+            (function() {
+                var getIteratorFn = function getIteratorFn(maybeIterable) {
+                    if (maybeIterable === null || typeof maybeIterable !== "object") {
+                        return null;
+                    }
+                    var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+                    if (typeof maybeIterator === "function") {
+                        return maybeIterator;
+                    }
+                    return null;
+                };
+                var setExtraStackFrame = function setExtraStackFrame(stack) {
+                    {
+                        currentExtraStackFrame = stack;
+                    }
+                };
+                var warn = // by calls to these methods by a Babel plugin.
+                //
+                // In PROD (or in packages without access to React internals),
+                // they are left as they are instead.
+                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];
+                            }
+                            printWarning("warn", format, args);
+                        }
+                    }
+                };
+                var error = 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];
+                            }
+                            printWarning("error", format, args);
+                        }
+                    }
+                };
+                var printWarning = function printWarning(level, format, args) {
+                    // When changing this logic, you might want to also
+                    // update consoleWithStackDev.www.js as well.
+                    {
+                        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+                        var stack = ReactDebugCurrentFrame.getStackAddendum();
+                        if (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
+                        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);
+                    }
+                };
+                var warnNoop = function warnNoop(publicInstance, callerName) {
+                    {
+                        var _constructor = publicInstance.constructor;
+                        var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass";
+                        var warningKey = componentName + "." + callerName;
+                        if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
+                            return;
+                        }
+                        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.", callerName, componentName);
+                        didWarnStateUpdateForUnmountedComponent[warningKey] = true;
+                    }
+                };
+                var Component = /**
+		 * Base class helpers for the updating state of a component.
+		 */ function Component(props, context, updater) {
+                    this.props = props;
+                    this.context = context; // If a component has string refs, we will assign a different object later.
+                    this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+                    // renderer.
+                    this.updater = updater || ReactNoopUpdateQueue;
+                };
+                var ComponentDummy = function ComponentDummy() {};
+                var PureComponent = /**
+		 * Convenience component with default shallow equality check for sCU.
+		 */ function PureComponent(props, context, updater) {
+                    this.props = props;
+                    this.context = context; // If a component has string refs, we will assign a different object later.
+                    this.refs = emptyObject;
+                    this.updater = updater || ReactNoopUpdateQueue;
+                };
+                var createRef = // an immutable object with a single mutable value
+                function createRef() {
+                    var refObject = {
+                        current: null
+                    };
+                    {
+                        Object.seal(refObject);
+                    }
+                    return refObject;
+                };
+                var isArray = function isArray(a) {
+                    return isArrayImpl(a);
+                };
+                var typeName = /*
+		 * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
+		 * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+		 *
+		 * The functions in this module will throw an easier-to-understand,
+		 * easier-to-debug exception with a clear errors message message explaining the
+		 * problem. (Instead of a confusing exception thrown inside the implementation
+		 * of the `value` object).
+		 */ // $FlowFixMe only called in DEV, so void return is not possible.
+                function typeName(value) {
+                    {
+                        // toStringTag is needed for namespaced types like Temporal.Instant
+                        var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
+                        var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+                        return type;
+                    }
+                } // $FlowFixMe only called in DEV, so void return is not possible.
+                ;
+                var willCoercionThrow = function willCoercionThrow(value) {
+                    {
+                        try {
+                            testStringCoercion(value);
+                            return false;
+                        } catch (e) {
+                            return true;
+                        }
+                    }
+                };
+                var testStringCoercion = function testStringCoercion(value) {
+                    // If you ended up here by following an exception call stack, here's what's
+                    // happened: you supplied an object or symbol value to React (as a prop, key,
+                    // DOM attribute, CSS property, string ref, etc.) and when React tried to
+                    // coerce it to a string using `'' + value`, an exception was thrown.
+                    //
+                    // The most common types that will cause this exception are `Symbol` instances
+                    // and Temporal objects like `Temporal.Instant`. But any object that has a
+                    // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+                    // exception. (Library authors do this to prevent users from using built-in
+                    // numeric operators like `+` or comparison operators like `>=` because custom
+                    // methods are needed to perform accurate arithmetic or comparison.)
+                    //
+                    // To fix the problem, coerce this object or symbol value to a string before
+                    // passing it to React. The most reliable way is usually `String(value)`.
+                    //
+                    // To find which value is throwing, check the browser or debugger console.
+                    // Before this exception was thrown, there should be `console.error` output
+                    // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+                    // problem and how that type was used: key, atrribute, input value prop, etc.
+                    // In most cases, this console output also shows the component and its
+                    // ancestor components where the exception happened.
+                    //
+                    // eslint-disable-next-line react-internal/safe-string-coercion
+                    return "" + value;
+                };
+                var checkKeyStringCoercion = function checkKeyStringCoercion(value) {
+                    {
+                        if (willCoercionThrow(value)) {
+                            error("The provided key is an unsupported type %s." + " This value must be coerced to a string before before using it here.", typeName(value));
+                            return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+                        }
+                    }
+                };
+                var getWrappedName = function getWrappedName(outerType, innerType, wrapperName) {
+                    var displayName = outerType.displayName;
+                    if (displayName) {
+                        return displayName;
+                    }
+                    var functionName = innerType.displayName || innerType.name || "";
+                    return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
+                } // Keep in sync with react-reconciler/getComponentNameFromFiber
+                ;
+                var getContextName = function getContextName(type) {
+                    return type.displayName || "Context";
+                } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+                ;
+                var hasValidRef = function hasValidRef(config) {
+                    {
+                        if (hasOwnProperty.call(config, "ref")) {
+                            var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
+                            if (getter && getter.isReactWarning) {
+                                return false;
+                            }
+                        }
+                    }
+                    return config.ref !== undefined;
+                };
+                var hasValidKey = function hasValidKey(config) {
+                    {
+                        if (hasOwnProperty.call(config, "key")) {
+                            var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+                            if (getter && getter.isReactWarning) {
+                                return false;
+                            }
+                        }
+                    }
+                    return config.key !== undefined;
+                };
+                var defineKeyPropWarningGetter = function defineKeyPropWarningGetter(props, displayName) {
+                    var warnAboutAccessingKey = function warnAboutAccessingKey() {
+                        {
+                            if (!specialPropKeyWarningShown) {
+                                specialPropKeyWarningShown = true;
+                                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://reactjs.org/link/special-props)", displayName);
+                            }
+                        }
+                    };
+                    warnAboutAccessingKey.isReactWarning = true;
+                    Object.defineProperty(props, "key", {
+                        get: warnAboutAccessingKey,
+                        configurable: true
+                    });
+                };
+                var defineRefPropWarningGetter = function defineRefPropWarningGetter(props, displayName) {
+                    var warnAboutAccessingRef = function warnAboutAccessingRef() {
+                        {
+                            if (!specialPropRefWarningShown) {
+                                specialPropRefWarningShown = true;
+                                error("%s: `ref` 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://reactjs.org/link/special-props)", displayName);
+                            }
+                        }
+                    };
+                    warnAboutAccessingRef.isReactWarning = true;
+                    Object.defineProperty(props, "ref", {
+                        get: warnAboutAccessingRef,
+                        configurable: true
+                    });
+                };
+                var warnIfStringRefCannotBeAutoConverted = function warnIfStringRefCannotBeAutoConverted(config) {
+                    {
+                        if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
+                            var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+                            if (!didWarnAboutStringRefs[componentName]) {
+                                error('Component "%s" contains the string ref "%s". ' + "Support for string refs will be removed in a future major release. " + "This case cannot be automatically converted to an arrow function. " + "We ask you to manually fix this case by using useRef() or createRef() instead. " + "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", componentName, config.ref);
+                                didWarnAboutStringRefs[componentName] = true;
+                            }
+                        }
+                    }
+                };
+                var createElement = /**
+		 * Create and return a new ReactElement of the given type.
+		 * See https://reactjs.org/docs/react-api.html#createelement
+		 */ function createElement(type, config, children) {
+                    var propName; // Reserved names are extracted
+                    var props = {};
+                    var key = null;
+                    var ref = null;
+                    var self = null;
+                    var source = null;
+                    if (config != null) {
+                        if (hasValidRef(config)) {
+                            ref = config.ref;
+                            {
+                                warnIfStringRefCannotBeAutoConverted(config);
+                            }
+                        }
+                        if (hasValidKey(config)) {
+                            {
+                                checkKeyStringCoercion(config.key);
+                            }
+                            key = "" + config.key;
+                        }
+                        self = config.__self === undefined ? null : config.__self;
+                        source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+                        for(propName in config){
+                            if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                                props[propName] = config[propName];
+                            }
+                        }
+                    } // Children can be more than one argument, and those are transferred onto
+                    // the newly allocated props object.
+                    var childrenLength = arguments.length - 2;
+                    if (childrenLength === 1) {
+                        props.children = children;
+                    } else if (childrenLength > 1) {
+                        var childArray = Array(childrenLength);
+                        for(var i = 0; i < childrenLength; i++){
+                            childArray[i] = arguments[i + 2];
+                        }
+                        {
+                            if (Object.freeze) {
+                                Object.freeze(childArray);
+                            }
+                        }
+                        props.children = childArray;
+                    } // Resolve default props
+                    if (type && type.defaultProps) {
+                        var defaultProps = type.defaultProps;
+                        for(propName in defaultProps){
+                            if (props[propName] === undefined) {
+                                props[propName] = defaultProps[propName];
+                            }
+                        }
+                    }
+                    {
+                        if (key || ref) {
+                            var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
+                            if (key) {
+                                defineKeyPropWarningGetter(props, displayName);
+                            }
+                            if (ref) {
+                                defineRefPropWarningGetter(props, displayName);
+                            }
+                        }
+                    }
+                    return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+                };
+                var cloneAndReplaceKey = function cloneAndReplaceKey(oldElement, newKey) {
+                    var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+                    return newElement;
+                };
+                var cloneElement = /**
+		 * Clone and return a new ReactElement using element as the starting point.
+		 * See https://reactjs.org/docs/react-api.html#cloneelement
+		 */ function cloneElement(element, config, children) {
+                    if (element === null || element === undefined) {
+                        throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+                    }
+                    var propName; // Original props are copied
+                    var props = assign({}, element.props); // Reserved names are extracted
+                    var key = element.key;
+                    var ref = element.ref; // Self is preserved since the owner is preserved.
+                    var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+                    // transpiler, and the original source is probably a better indicator of the
+                    // true owner.
+                    var source = element._source; // Owner will be preserved, unless ref is overridden
+                    var owner = element._owner;
+                    if (config != null) {
+                        if (hasValidRef(config)) {
+                            // Silently steal the ref from the parent.
+                            ref = config.ref;
+                            owner = ReactCurrentOwner.current;
+                        }
+                        if (hasValidKey(config)) {
+                            {
+                                checkKeyStringCoercion(config.key);
+                            }
+                            key = "" + config.key;
+                        } // Remaining properties override existing props
+                        var defaultProps;
+                        if (element.type && element.type.defaultProps) {
+                            defaultProps = element.type.defaultProps;
+                        }
+                        for(propName in config){
+                            if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                                if (config[propName] === undefined && defaultProps !== undefined) {
+                                    // Resolve default props
+                                    props[propName] = defaultProps[propName];
+                                } else {
+                                    props[propName] = config[propName];
+                                }
+                            }
+                        }
+                    } // Children can be more than one argument, and those are transferred onto
+                    // the newly allocated props object.
+                    var childrenLength = arguments.length - 2;
+                    if (childrenLength === 1) {
+                        props.children = children;
+                    } else if (childrenLength > 1) {
+                        var childArray = Array(childrenLength);
+                        for(var i = 0; i < childrenLength; i++){
+                            childArray[i] = arguments[i + 2];
+                        }
+                        props.children = childArray;
+                    }
+                    return ReactElement(element.type, key, ref, self, source, owner, props);
+                };
+                var isValidElement = /**
+		 * Verifies the object is a ReactElement.
+		 * See https://reactjs.org/docs/react-api.html#isvalidelement
+		 * @param {?object} object
+		 * @return {boolean} True if `object` is a ReactElement.
+		 * @final
+		 */ function isValidElement(object) {
+                    return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+                };
+                var escape = /**
+		 * Escape and wrap key so it is safe to use as a reactid
+		 *
+		 * @param {string} key to be escaped.
+		 * @return {string} the escaped key.
+		 */ function escape(key) {
+                    var escapeRegex = /[=:]/g;
+                    var escaperLookup = {
+                        "=": "=0",
+                        ":": "=2"
+                    };
+                    var escapedString = key.replace(escapeRegex, function(match) {
+                        return escaperLookup[match];
+                    });
+                    return "$" + escapedString;
+                };
+                var escapeUserProvidedKey = function escapeUserProvidedKey(text) {
+                    return text.replace(userProvidedKeyEscapeRegex, "$&/");
+                };
+                var getElementKey = /**
+		 * Generate a key string that identifies a element within a set.
+		 *
+		 * @param {*} element A element that could contain a manual key.
+		 * @param {number} index Index that is used if a manual key is not provided.
+		 * @return {string}
+		 */ function getElementKey(element, index) {
+                    // Do some typechecking here since we call this blindly. We want to ensure
+                    // that we don't block potential future ES APIs.
+                    if (typeof element === "object" && element !== null && element.key != null) {
+                        // Explicit key
+                        {
+                            checkKeyStringCoercion(element.key);
+                        }
+                        return escape("" + element.key);
+                    } // Implicit key determined by the index in the set
+                    return index.toString(36);
+                };
+                var mapChildren = /**
+		 * Maps children that are typically specified as `props.children`.
+		 *
+		 * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+		 *
+		 * The provided mapFunction(child, index) will be called for each
+		 * leaf child.
+		 *
+		 * @param {?*} children Children tree container.
+		 * @param {function(*, int)} func The map function.
+		 * @param {*} context Context for mapFunction.
+		 * @return {object} Object containing the ordered map of results.
+		 */ function mapChildren(children, func, context) {
+                    if (children == null) {
+                        return children;
+                    }
+                    var result = [];
+                    var count = 0;
+                    mapIntoArray(children, result, "", "", function(child) {
+                        return func.call(context, child, count++);
+                    });
+                    return result;
+                };
+                var countChildren = /**
+		 * Count the number of children that are typically specified as
+		 * `props.children`.
+		 *
+		 * See https://reactjs.org/docs/react-api.html#reactchildrencount
+		 *
+		 * @param {?*} children Children tree container.
+		 * @return {number} The number of children.
+		 */ function countChildren(children) {
+                    var n = 0;
+                    mapChildren(children, function() {
+                        n++; // Don't return anything
+                    });
+                    return n;
+                };
+                var forEachChildren = /**
+		 * Iterates through children that are typically specified as `props.children`.
+		 *
+		 * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+		 *
+		 * The provided forEachFunc(child, index) will be called for each
+		 * leaf child.
+		 *
+		 * @param {?*} children Children tree container.
+		 * @param {function(*, int)} forEachFunc
+		 * @param {*} forEachContext Context for forEachContext.
+		 */ function forEachChildren(children, forEachFunc, forEachContext) {
+                    mapChildren(children, function() {
+                        forEachFunc.apply(this, arguments); // Don't return anything.
+                    }, forEachContext);
+                };
+                var toArray = /**
+		 * Flatten a children object (typically specified as `props.children`) and
+		 * return an array with appropriately re-keyed children.
+		 *
+		 * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+		 */ function toArray(children) {
+                    return mapChildren(children, function(child) {
+                        return child;
+                    }) || [];
+                };
+                var onlyChild = /**
+		 * Returns the first child in a collection of children and verifies that there
+		 * is only one child in the collection.
+		 *
+		 * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+		 *
+		 * The current implementation of this function assumes that a single child gets
+		 * passed without a wrapper, but the purpose of this helper function is to
+		 * abstract away the particular structure of children.
+		 *
+		 * @param {?object} children Child collection structure.
+		 * @return {ReactElement} The first and only `ReactElement` contained in the
+		 * structure.
+		 */ function onlyChild(children) {
+                    if (!isValidElement(children)) {
+                        throw new Error("React.Children.only expected to receive a single React element child.");
+                    }
+                    return children;
+                };
+                var createContext = function createContext(defaultValue) {
+                    // TODO: Second argument used to be an optional `calculateChangedBits`
+                    // function. Warn to reserve for future use?
+                    var context = {
+                        $$typeof: REACT_CONTEXT_TYPE,
+                        // As a workaround to support multiple concurrent renderers, we categorize
+                        // some renderers as primary and others as secondary. We only expect
+                        // there to be two concurrent renderers at most: React Native (primary) and
+                        // Fabric (secondary); React DOM (primary) and React ART (secondary).
+                        // Secondary renderers store their context values on separate fields.
+                        _currentValue: defaultValue,
+                        _currentValue2: defaultValue,
+                        // Used to track how many concurrent renderers this context currently
+                        // supports within in a single renderer. Such as parallel server rendering.
+                        _threadCount: 0,
+                        // These are circular
+                        Provider: null,
+                        Consumer: null,
+                        // Add these to use same hidden class in VM as ServerContext
+                        _defaultValue: null,
+                        _globalName: null
+                    };
+                    context.Provider = {
+                        $$typeof: REACT_PROVIDER_TYPE,
+                        _context: context
+                    };
+                    var hasWarnedAboutUsingNestedContextConsumers = false;
+                    var hasWarnedAboutUsingConsumerProvider = false;
+                    var hasWarnedAboutDisplayNameOnConsumer = false;
+                    {
+                        // A separate object, but proxies back to the original context object for
+                        // backwards compatibility. It has a different $$typeof, so we can properly
+                        // warn for the incorrect usage of Context as a Consumer.
+                        var Consumer = {
+                            $$typeof: REACT_CONTEXT_TYPE,
+                            _context: context
+                        }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
+                        Object.defineProperties(Consumer, {
+                            Provider: {
+                                get: function get() {
+                                    if (!hasWarnedAboutUsingConsumerProvider) {
+                                        hasWarnedAboutUsingConsumerProvider = true;
+                                        error("Rendering <Context.Consumer.Provider> is not supported and will be removed in " + "a future major release. Did you mean to render <Context.Provider> instead?");
+                                    }
+                                    return context.Provider;
+                                },
+                                set: function set(_Provider) {
+                                    context.Provider = _Provider;
+                                }
+                            },
+                            _currentValue: {
+                                get: function get() {
+                                    return context._currentValue;
+                                },
+                                set: function set(_currentValue) {
+                                    context._currentValue = _currentValue;
+                                }
+                            },
+                            _currentValue2: {
+                                get: function get() {
+                                    return context._currentValue2;
+                                },
+                                set: function set(_currentValue2) {
+                                    context._currentValue2 = _currentValue2;
+                                }
+                            },
+                            _threadCount: {
+                                get: function get() {
+                                    return context._threadCount;
+                                },
+                                set: function set(_threadCount) {
+                                    context._threadCount = _threadCount;
+                                }
+                            },
+                            Consumer: {
+                                get: function get() {
+                                    if (!hasWarnedAboutUsingNestedContextConsumers) {
+                                        hasWarnedAboutUsingNestedContextConsumers = true;
+                                        error("Rendering <Context.Consumer.Consumer> is not supported and will be removed in " + "a future major release. Did you mean to render <Context.Consumer> instead?");
+                                    }
+                                    return context.Consumer;
+                                }
+                            },
+                            displayName: {
+                                get: function get() {
+                                    return context.displayName;
+                                },
+                                set: function set(displayName) {
+                                    if (!hasWarnedAboutDisplayNameOnConsumer) {
+                                        warn("Setting `displayName` on Context.Consumer has no effect. " + "You should set it directly on the context with Context.displayName = '%s'.", displayName);
+                                        hasWarnedAboutDisplayNameOnConsumer = true;
+                                    }
+                                }
+                            }
+                        }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
+                        context.Consumer = Consumer;
+                    }
+                    {
+                        context._currentRenderer = null;
+                        context._currentRenderer2 = null;
+                    }
+                    return context;
+                };
+                var lazyInitializer = function lazyInitializer(payload) {
+                    if (payload._status === Uninitialized) {
+                        var ctor = payload._result;
+                        var thenable = ctor(); // Transition to the next state.
+                        // This might throw either because it's missing or throws. If so, we treat it
+                        // as still uninitialized and try again next time. Which is the same as what
+                        // happens if the ctor or any wrappers processing the ctor throws. This might
+                        // end up fixing it if the resolution was a concurrency bug.
+                        thenable.then(function(moduleObject) {
+                            if (payload._status === Pending || payload._status === Uninitialized) {
+                                // Transition to the next state.
+                                var resolved = payload;
+                                resolved._status = Resolved;
+                                resolved._result = moduleObject;
+                            }
+                        }, function(error) {
+                            if (payload._status === Pending || payload._status === Uninitialized) {
+                                // Transition to the next state.
+                                var rejected = payload;
+                                rejected._status = Rejected;
+                                rejected._result = error;
+                            }
+                        });
+                        if (payload._status === Uninitialized) {
+                            // In case, we're still uninitialized, then we're waiting for the thenable
+                            // to resolve. Set it as pending in the meantime.
+                            var pending = payload;
+                            pending._status = Pending;
+                            pending._result = thenable;
+                        }
+                    }
+                    if (payload._status === Resolved) {
+                        var moduleObject = payload._result;
+                        {
+                            if (moduleObject === undefined) {
+                                error("lazy: Expected the result of a dynamic imp" + "ort() call. " + "Instead received: %s\n\nYour code should look like: \n  " + // Break up imports to avoid accidentally parsing them as dependencies.
+                                "const MyComponent = lazy(() => imp" + "ort('./MyComponent'))\n\n" + "Did you accidentally put curly braces around the import?", moduleObject);
+                            }
+                        }
+                        {
+                            if (!("default" in moduleObject)) {
+                                error("lazy: Expected the result of a dynamic imp" + "ort() call. " + "Instead received: %s\n\nYour code should look like: \n  " + // Break up imports to avoid accidentally parsing them as dependencies.
+                                "const MyComponent = lazy(() => imp" + "ort('./MyComponent'))", moduleObject);
+                            }
+                        }
+                        return moduleObject.default;
+                    } else {
+                        throw payload._result;
+                    }
+                };
+                var lazy = function lazy(ctor) {
+                    var payload = {
+                        // We use these fields to store the result.
+                        _status: Uninitialized,
+                        _result: ctor
+                    };
+                    var lazyType = {
+                        $$typeof: REACT_LAZY_TYPE,
+                        _payload: payload,
+                        _init: lazyInitializer
+                    };
+                    {
+                        // In production, this would just set it on the object.
+                        var defaultProps;
+                        var propTypes; // $FlowFixMe
+                        Object.defineProperties(lazyType, {
+                            defaultProps: {
+                                configurable: true,
+                                get: function get() {
+                                    return defaultProps;
+                                },
+                                set: function set(newDefaultProps) {
+                                    error("React.lazy(...): It is not supported to assign `defaultProps` to " + "a lazy component import. Either specify them where the component " + "is defined, or create a wrapping component around it.");
+                                    defaultProps = newDefaultProps; // Match production behavior more closely:
+                                    // $FlowFixMe
+                                    Object.defineProperty(lazyType, "defaultProps", {
+                                        enumerable: true
+                                    });
+                                }
+                            },
+                            propTypes: {
+                                configurable: true,
+                                get: function get() {
+                                    return propTypes;
+                                },
+                                set: function set(newPropTypes) {
+                                    error("React.lazy(...): It is not supported to assign `propTypes` to " + "a lazy component import. Either specify them where the component " + "is defined, or create a wrapping component around it.");
+                                    propTypes = newPropTypes; // Match production behavior more closely:
+                                    // $FlowFixMe
+                                    Object.defineProperty(lazyType, "propTypes", {
+                                        enumerable: true
+                                    });
+                                }
+                            }
+                        });
+                    }
+                    return lazyType;
+                };
+                var forwardRef = function forwardRef(render) {
+                    {
+                        if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
+                            error("forwardRef requires a render function but received a `memo` " + "component. Instead of forwardRef(memo(...)), use " + "memo(forwardRef(...)).");
+                        } else if (typeof render !== "function") {
+                            error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render === "undefined" ? "undefined" : _typeof(render));
+                        } else {
+                            if (render.length !== 0 && render.length !== 2) {
+                                error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+                            }
+                        }
+                        if (render != null) {
+                            if (render.defaultProps != null || render.propTypes != null) {
+                                error("forwardRef render functions do not support propTypes or defaultProps. " + "Did you accidentally pass a React component?");
+                            }
+                        }
+                    }
+                    var elementType = {
+                        $$typeof: REACT_FORWARD_REF_TYPE,
+                        render: render
+                    };
+                    {
+                        var ownName;
+                        Object.defineProperty(elementType, "displayName", {
+                            enumerable: false,
+                            configurable: true,
+                            get: function get() {
+                                return ownName;
+                            },
+                            set: function set(name) {
+                                ownName = name; // The inner component shouldn't inherit this display name in most cases,
+                                // because the component may be used elsewhere.
+                                // But it's nice for anonymous functions to inherit the name,
+                                // so that our component-stack generation logic will display their frames.
+                                // An anonymous function generally suggests a pattern like:
+                                //   React.forwardRef((props, ref) => {...});
+                                // This kind of inner function is not used elsewhere so the side effect is okay.
+                                if (!render.name && !render.displayName) {
+                                    render.displayName = name;
+                                }
+                            }
+                        });
+                    }
+                    return elementType;
+                };
+                var isValidElementType = function isValidElementType(type) {
+                    if (typeof type === "string" || typeof type === "function") {
+                        return true;
+                    } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+                    if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
+                        return true;
+                    }
+                    if (typeof type === "object" && type !== null) {
+                        if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+                        // types supported by any Flight configuration anywhere since
+                        // we don't know which Flight build this will end up being used
+                        // with.
+                        type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+                var memo = function memo(type, compare) {
+                    {
+                        if (!isValidElementType(type)) {
+                            error("memo: The first argument must be a component. Instead " + "received: %s", type === null ? "null" : typeof type === "undefined" ? "undefined" : _typeof(type));
+                        }
+                    }
+                    var elementType = {
+                        $$typeof: REACT_MEMO_TYPE,
+                        type: type,
+                        compare: compare === undefined ? null : compare
+                    };
+                    {
+                        var ownName;
+                        Object.defineProperty(elementType, "displayName", {
+                            enumerable: false,
+                            configurable: true,
+                            get: function get() {
+                                return ownName;
+                            },
+                            set: function set(name) {
+                                ownName = name; // The inner component shouldn't inherit this display name in most cases,
+                                // because the component may be used elsewhere.
+                                // But it's nice for anonymous functions to inherit the name,
+                                // so that our component-stack generation logic will display their frames.
+                                // An anonymous function generally suggests a pattern like:
+                                //   React.memo((props) => {...});
+                                // This kind of inner function is not used elsewhere so the side effect is okay.
+                                if (!type.name && !type.displayName) {
+                                    type.displayName = name;
+                                }
+                            }
+                        });
+                    }
+                    return elementType;
+                };
+                var resolveDispatcher = function resolveDispatcher() {
+                    var dispatcher = ReactCurrentDispatcher.current;
+                    {
+                        if (dispatcher === null) {
+                            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:\n" + "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" + "2. You might be breaking the Rules of Hooks\n" + "3. You might have more than one copy of React in the same app\n" + "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
+                        }
+                    }
+                    // intentionally don't throw our own error because this is in a hot path.
+                    // Also helps ensure this is inlined.
+                    return dispatcher;
+                };
+                var useContext = function useContext(Context) {
+                    var dispatcher = resolveDispatcher();
+                    {
+                        // TODO: add a more generic warning for invalid values.
+                        if (Context._context !== undefined) {
+                            var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
+                            // and nobody should be using this in existing code.
+                            if (realContext.Consumer === Context) {
+                                error("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be " + "removed in a future major release. Did you mean to call useContext(Context) instead?");
+                            } else if (realContext.Provider === Context) {
+                                error("Calling useContext(Context.Provider) is not supported. " + "Did you mean to call useContext(Context) instead?");
+                            }
+                        }
+                    }
+                    return dispatcher.useContext(Context);
+                };
+                var useState = function useState(initialState) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useState(initialState);
+                };
+                var useReducer = function useReducer(reducer, initialArg, init) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useReducer(reducer, initialArg, init);
+                };
+                var useRef = function useRef(initialValue) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useRef(initialValue);
+                };
+                var useEffect = function useEffect(create, deps) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useEffect(create, deps);
+                };
+                var useInsertionEffect = function useInsertionEffect(create, deps) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useInsertionEffect(create, deps);
+                };
+                var useLayoutEffect = function useLayoutEffect(create, deps) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useLayoutEffect(create, deps);
+                };
+                var useCallback = function useCallback(callback, deps) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useCallback(callback, deps);
+                };
+                var useMemo = function useMemo(create, deps) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useMemo(create, deps);
+                };
+                var useImperativeHandle = function useImperativeHandle(ref, create, deps) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useImperativeHandle(ref, create, deps);
+                };
+                var useDebugValue = function useDebugValue(value, formatterFn) {
+                    {
+                        var dispatcher = resolveDispatcher();
+                        return dispatcher.useDebugValue(value, formatterFn);
+                    }
+                };
+                var useTransition = function useTransition() {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useTransition();
+                };
+                var useDeferredValue = function useDeferredValue(value) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useDeferredValue(value);
+                };
+                var useId = function useId() {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useId();
+                };
+                var useSyncExternalStore = function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+                    var dispatcher = resolveDispatcher();
+                    return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+                };
+                var disabledLog = function disabledLog() {};
+                var disableLogs = function disableLogs() {
+                    {
+                        if (disabledDepth === 0) {
+                            /* eslint-disable react-internal/no-production-logging */ prevLog = console.log;
+                            prevInfo = console.info;
+                            prevWarn = console.warn;
+                            prevError = console.error;
+                            prevGroup = console.group;
+                            prevGroupCollapsed = console.groupCollapsed;
+                            prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+                            var props = {
+                                configurable: true,
+                                enumerable: true,
+                                value: disabledLog,
+                                writable: true
+                            }; // $FlowFixMe Flow thinks console is immutable.
+                            Object.defineProperties(console, {
+                                info: props,
+                                log: props,
+                                warn: props,
+                                error: props,
+                                group: props,
+                                groupCollapsed: props,
+                                groupEnd: props
+                            });
+                        /* eslint-enable react-internal/no-production-logging */ }
+                        disabledDepth++;
+                    }
+                };
+                var reenableLogs = function reenableLogs() {
+                    {
+                        disabledDepth--;
+                        if (disabledDepth === 0) {
+                            /* eslint-disable react-internal/no-production-logging */ var props = {
+                                configurable: true,
+                                enumerable: true,
+                                writable: true
+                            }; // $FlowFixMe Flow thinks console is immutable.
+                            Object.defineProperties(console, {
+                                log: assign({}, props, {
+                                    value: prevLog
+                                }),
+                                info: assign({}, props, {
+                                    value: prevInfo
+                                }),
+                                warn: assign({}, props, {
+                                    value: prevWarn
+                                }),
+                                error: assign({}, props, {
+                                    value: prevError
+                                }),
+                                group: assign({}, props, {
+                                    value: prevGroup
+                                }),
+                                groupCollapsed: assign({}, props, {
+                                    value: prevGroupCollapsed
+                                }),
+                                groupEnd: assign({}, props, {
+                                    value: prevGroupEnd
+                                })
+                            });
+                        /* eslint-enable react-internal/no-production-logging */ }
+                        if (disabledDepth < 0) {
+                            error("disabledDepth fell below zero. " + "This is a bug in React. Please file an issue.");
+                        }
+                    }
+                };
+                var describeBuiltInComponentFrame = function describeBuiltInComponentFrame(name, source, ownerFn) {
+                    {
+                        if (prefix === undefined) {
+                            // Extract the VM specific prefix used by each line.
+                            try {
+                                throw Error();
+                            } catch (x) {
+                                var match = x.stack.trim().match(/\n( *(at )?)/);
+                                prefix = match && match[1] || "";
+                            }
+                        } // We use the prefix to ensure our stacks line up with native stack frames.
+                        return "\n" + prefix + name;
+                    }
+                };
+                var describeNativeComponentFrame = function describeNativeComponentFrame(fn, construct) {
+                    // If something asked for a stack inside a fake render, it should get ignored.
+                    if (!fn || reentry) {
+                        return "";
+                    }
+                    {
+                        var frame = componentFrameCache.get(fn);
+                        if (frame !== undefined) {
+                            return frame;
+                        }
+                    }
+                    var control;
+                    reentry = true;
+                    var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
+                    Error.prepareStackTrace = undefined;
+                    var previousDispatcher;
+                    {
+                        previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
+                        // for warnings.
+                        ReactCurrentDispatcher$1.current = null;
+                        disableLogs();
+                    }
+                    try {
+                        // This should throw.
+                        if (construct) {
+                            // Something should be setting the props in the constructor.
+                            var Fake = function Fake() {
+                                throw Error();
+                            }; // $FlowFixMe
+                            Object.defineProperty(Fake.prototype, "props", {
+                                set: function set() {
+                                    // We use a throwing setter instead of frozen or non-writable props
+                                    // because that won't throw in a non-strict mode function.
+                                    throw Error();
+                                }
+                            });
+                            if (typeof Reflect === "object" && Reflect.construct) {
+                                // We construct a different control for this case to include any extra
+                                // frames added by the construct call.
+                                try {
+                                    Reflect.construct(Fake, []);
+                                } catch (x) {
+                                    control = x;
+                                }
+                                Reflect.construct(fn, [], Fake);
+                            } else {
+                                try {
+                                    Fake.call();
+                                } catch (x1) {
+                                    control = x1;
+                                }
+                                fn.call(Fake.prototype);
+                            }
+                        } else {
+                            try {
+                                throw Error();
+                            } catch (x2) {
+                                control = x2;
+                            }
+                            fn();
+                        }
+                    } catch (sample) {
+                        // This is inlined manually because closure doesn't do it for us.
+                        if (sample && control && typeof sample.stack === "string") {
+                            // This extracts the first frame from the sample that isn't also in the control.
+                            // Skipping one frame that we assume is the frame that calls the two.
+                            var sampleLines = sample.stack.split("\n");
+                            var controlLines = control.stack.split("\n");
+                            var s = sampleLines.length - 1;
+                            var c = controlLines.length - 1;
+                            while(s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]){
+                                // We expect at least one stack frame to be shared.
+                                // Typically this will be the root most one. However, stack frames may be
+                                // cut off due to maximum stack limits. In this case, one maybe cut off
+                                // earlier than the other. We assume that the sample is longer or the same
+                                // and there for cut off earlier. So we should find the root most frame in
+                                // the sample somewhere in the control.
+                                c--;
+                            }
+                            for(; s >= 1 && c >= 0; s--, c--){
+                                // Next we find the first one that isn't the same which should be the
+                                // frame that called our sample function and the control.
+                                if (sampleLines[s] !== controlLines[c]) {
+                                    // In V8, the first line is describing the message but other VMs don't.
+                                    // If we're about to return the first line, and the control is also on the same
+                                    // line, that's a pretty good indicator that our sample threw at same line as
+                                    // the control. I.e. before we entered the sample frame. So we ignore this result.
+                                    // This can happen if you passed a class to function component, or non-function.
+                                    if (s !== 1 || c !== 1) {
+                                        do {
+                                            s--;
+                                            c--; // We may still have similar intermediate frames from the construct call.
+                                            // The next one that isn't the same should be our match though.
+                                            if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                                                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                                                var _frame = "\n" + sampleLines[s].replace(" at new ", " at "); // If our component frame is labeled "<anonymous>"
+                                                // but we have a user-provided "displayName"
+                                                // splice it in to make the stack more readable.
+                                                if (fn.displayName && _frame.includes("<anonymous>")) {
+                                                    _frame = _frame.replace("<anonymous>", fn.displayName);
+                                                }
+                                                {
+                                                    if (typeof fn === "function") {
+                                                        componentFrameCache.set(fn, _frame);
+                                                    }
+                                                }
+                                                return _frame;
+                                            }
+                                        }while (s >= 1 && c >= 0);
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    } finally{
+                        reentry = false;
+                        {
+                            ReactCurrentDispatcher$1.current = previousDispatcher;
+                            reenableLogs();
+                        }
+                        Error.prepareStackTrace = previousPrepareStackTrace;
+                    } // Fallback to just using the name if we couldn't make it throw.
+                    var name = fn ? fn.displayName || fn.name : "";
+                    var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
+                    {
+                        if (typeof fn === "function") {
+                            componentFrameCache.set(fn, syntheticFrame);
+                        }
+                    }
+                    return syntheticFrame;
+                };
+                var describeFunctionComponentFrame = function describeFunctionComponentFrame(fn, source, ownerFn) {
+                    {
+                        return describeNativeComponentFrame(fn, false);
+                    }
+                };
+                var shouldConstruct = function shouldConstruct(Component) {
+                    var prototype = Component.prototype;
+                    return !!(prototype && prototype.isReactComponent);
+                };
+                var setCurrentlyValidatingElement = function setCurrentlyValidatingElement(element) {
+                    {
+                        if (element) {
+                            var owner = element._owner;
+                            var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+                            ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+                        } else {
+                            ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+                        }
+                    }
+                };
+                var checkPropTypes = function checkPropTypes(typeSpecs, values, location, componentName, element) {
+                    {
+                        // $FlowFixMe This is okay but Flow doesn't know it.
+                        var has = Function.call.bind(hasOwnProperty);
+                        for(var typeSpecName in typeSpecs){
+                            if (has(typeSpecs, typeSpecName)) {
+                                var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+                                // fail the render phase where it didn't fail before. So we log it.
+                                // After these have been cleaned up, we'll let them throw.
+                                try {
+                                    // This is intentionally an invariant that gets caught. It's the same
+                                    // behavior as without this statement except with a better message.
+                                    if (typeof typeSpecs[typeSpecName] !== "function") {
+                                        // eslint-disable-next-line react-internal/prod-error-codes
+                                        var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + _typeof(typeSpecs[typeSpecName]) + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                                        err.name = "Invariant Violation";
+                                        throw err;
+                                    }
+                                    error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+                                } catch (ex) {
+                                    error$1 = ex;
+                                }
+                                if (error$1 && !_instanceof(error$1, Error)) {
+                                    setCurrentlyValidatingElement(element);
+                                    error("%s: type specification of %s" + " `%s` is invalid; the type checker " + "function must return `null` or an `Error` but returned a %s. " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1 === "undefined" ? "undefined" : _typeof(error$1));
+                                    setCurrentlyValidatingElement(null);
+                                }
+                                if (_instanceof(error$1, Error) && !(error$1.message in loggedTypeFailures)) {
+                                    // Only monitor this failure once because there tends to be a lot of the
+                                    // same error.
+                                    loggedTypeFailures[error$1.message] = true;
+                                    setCurrentlyValidatingElement(element);
+                                    error("Failed %s type: %s", location, error$1.message);
+                                    setCurrentlyValidatingElement(null);
+                                }
+                            }
+                        }
+                    }
+                };
+                var setCurrentlyValidatingElement$1 = function setCurrentlyValidatingElement$1(element) {
+                    {
+                        if (element) {
+                            var owner = element._owner;
+                            var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+                            setExtraStackFrame(stack);
+                        } else {
+                            setExtraStackFrame(null);
+                        }
+                    }
+                };
+                var getDeclarationErrorAddendum = function getDeclarationErrorAddendum() {
+                    if (ReactCurrentOwner.current) {
+                        var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+                        if (name) {
+                            return "\n\nCheck the render method of `" + name + "`.";
+                        }
+                    }
+                    return "";
+                };
+                var getSourceInfoErrorAddendum = function getSourceInfoErrorAddendum(source) {
+                    if (source !== undefined) {
+                        var fileName = source.fileName.replace(/^.*[\\\/]/, "");
+                        var lineNumber = source.lineNumber;
+                        return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
+                    }
+                    return "";
+                };
+                var getSourceInfoErrorAddendumForProps = function getSourceInfoErrorAddendumForProps(elementProps) {
+                    if (elementProps !== null && elementProps !== undefined) {
+                        return getSourceInfoErrorAddendum(elementProps.__source);
+                    }
+                    return "";
+                };
+                var getCurrentComponentErrorInfo = function getCurrentComponentErrorInfo(parentType) {
+                    var info = getDeclarationErrorAddendum();
+                    if (!info) {
+                        var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
+                        if (parentName) {
+                            info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+                        }
+                    }
+                    return info;
+                };
+                var validateExplicitKey = /**
+		 * Warn if the element doesn't have an explicit key assigned to it.
+		 * This element is in an array. The array could grow and shrink or be
+		 * reordered. All children that haven't already been validated are required to
+		 * have a "key" property assigned to it. Error statuses are cached so a warning
+		 * will only be shown once.
+		 *
+		 * @internal
+		 * @param {ReactElement} element Element that requires a key.
+		 * @param {*} parentType element's parent's type.
+		 */ function validateExplicitKey(element, parentType) {
+                    if (!element._store || element._store.validated || element.key != null) {
+                        return;
+                    }
+                    element._store.validated = true;
+                    var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+                    if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+                        return;
+                    }
+                    ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+                    // property, it may be the creator of the child that's responsible for
+                    // assigning it a key.
+                    var childOwner = "";
+                    if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+                        // Give the component that originally created this child.
+                        childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+                    }
+                    {
+                        setCurrentlyValidatingElement$1(element);
+                        error('Each child in a list should have a unique "key" prop.' + "%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, childOwner);
+                        setCurrentlyValidatingElement$1(null);
+                    }
+                };
+                var validateChildKeys = /**
+		 * Ensure that every element either is passed in a static location, in an
+		 * array with an explicit keys property defined, or in an object literal
+		 * with valid key property.
+		 *
+		 * @internal
+		 * @param {ReactNode} node Statically passed child of any type.
+		 * @param {*} parentType node's parent's type.
+		 */ function validateChildKeys(node, parentType) {
+                    if (typeof node !== "object") {
+                        return;
+                    }
+                    if (isArray(node)) {
+                        for(var i = 0; i < node.length; i++){
+                            var child = node[i];
+                            if (isValidElement(child)) {
+                                validateExplicitKey(child, parentType);
+                            }
+                        }
+                    } else if (isValidElement(node)) {
+                        // This element was passed in a valid location.
+                        if (node._store) {
+                            node._store.validated = true;
+                        }
+                    } else if (node) {
+                        var iteratorFn = getIteratorFn(node);
+                        if (typeof iteratorFn === "function") {
+                            // Entry iterators used to provide implicit keys,
+                            // but now we print a separate warning for them later.
+                            if (iteratorFn !== node.entries) {
+                                var iterator = iteratorFn.call(node);
+                                var step;
+                                while(!(step = iterator.next()).done){
+                                    if (isValidElement(step.value)) {
+                                        validateExplicitKey(step.value, parentType);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+                var validatePropTypes = /**
+		 * Given an element, validate that its props follow the propTypes definition,
+		 * provided by the type.
+		 *
+		 * @param {ReactElement} element
+		 */ function validatePropTypes(element) {
+                    {
+                        var type = element.type;
+                        if (type === null || type === undefined || typeof type === "string") {
+                            return;
+                        }
+                        var propTypes;
+                        if (typeof type === "function") {
+                            propTypes = type.propTypes;
+                        } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+                        // Inner props are checked in the reconciler.
+                        type.$$typeof === REACT_MEMO_TYPE)) {
+                            propTypes = type.propTypes;
+                        } else {
+                            return;
+                        }
+                        if (propTypes) {
+                            // Intentionally inside to avoid triggering lazy initializers:
+                            var name = getComponentNameFromType(type);
+                            checkPropTypes(propTypes, element.props, "prop", name, element);
+                        } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+                            propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
+                            var _name = getComponentNameFromType(type);
+                            error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
+                        }
+                        if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
+                            error("getDefaultProps is only used on classic React.createClass " + "definitions. Use a static property named `defaultProps` instead.");
+                        }
+                    }
+                };
+                var validateFragmentProps = /**
+		 * Given a fragment, validate that it can only be provided with fragment props
+		 * @param {ReactElement} fragment
+		 */ function validateFragmentProps(fragment) {
+                    {
+                        var keys = Object.keys(fragment.props);
+                        for(var i = 0; i < keys.length; i++){
+                            var key = keys[i];
+                            if (key !== "children" && key !== "key") {
+                                setCurrentlyValidatingElement$1(fragment);
+                                error("Invalid prop `%s` supplied to `React.Fragment`. " + "React.Fragment can only have `key` and `children` props.", key);
+                                setCurrentlyValidatingElement$1(null);
+                                break;
+                            }
+                        }
+                        if (fragment.ref !== null) {
+                            setCurrentlyValidatingElement$1(fragment);
+                            error("Invalid attribute `ref` supplied to `React.Fragment`.");
+                            setCurrentlyValidatingElement$1(null);
+                        }
+                    }
+                };
+                var createElementWithValidation = function createElementWithValidation(type, props, children) {
+                    var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+                    // succeed and there will likely be errors in render.
+                    if (!validType) {
+                        var info = "";
+                        if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
+                            info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and named imports.";
+                        }
+                        var sourceInfo = getSourceInfoErrorAddendumForProps(props);
+                        if (sourceInfo) {
+                            info += sourceInfo;
+                        } else {
+                            info += getDeclarationErrorAddendum();
+                        }
+                        var typeString;
+                        if (type === null) {
+                            typeString = "null";
+                        } else if (isArray(type)) {
+                            typeString = "array";
+                        } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+                            typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
+                            info = " Did you accidentally export a JSX literal instead of a component?";
+                        } else {
+                            typeString = typeof type === "undefined" ? "undefined" : _typeof(type);
+                        }
+                        {
+                            error("React.createElement: type is invalid -- expected a string (for " + "built-in components) or a class/function (for composite " + "components) but got: %s.%s", typeString, info);
+                        }
+                    }
+                    var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
+                    // TODO: Drop this when these are no longer allowed as the type argument.
+                    if (element == null) {
+                        return element;
+                    } // Skip key warning if the type isn't valid since our key validation logic
+                    // doesn't expect a non-string/function type and can throw confusing errors.
+                    // We don't want exception behavior to differ between dev and prod.
+                    // (Rendering will throw with a helpful message and as soon as the type is
+                    // fixed, the key warnings will appear.)
+                    if (validType) {
+                        for(var i = 2; i < arguments.length; i++){
+                            validateChildKeys(arguments[i], type);
+                        }
+                    }
+                    if (type === REACT_FRAGMENT_TYPE) {
+                        validateFragmentProps(element);
+                    } else {
+                        validatePropTypes(element);
+                    }
+                    return element;
+                };
+                var createFactoryWithValidation = function createFactoryWithValidation(type) {
+                    var validatedFactory = createElementWithValidation.bind(null, type);
+                    validatedFactory.type = type;
+                    {
+                        if (!didWarnAboutDeprecatedCreateFactory) {
+                            didWarnAboutDeprecatedCreateFactory = true;
+                            warn("React.createFactory() is deprecated and will be removed in " + "a future major release. Consider using JSX " + "or use React.createElement() directly instead.");
+                        } // Legacy hook: remove it
+                        Object.defineProperty(validatedFactory, "type", {
+                            enumerable: false,
+                            get: function get() {
+                                warn("Factory.type is deprecated. Access the class directly " + "before passing it to createFactory.");
+                                Object.defineProperty(this, "type", {
+                                    value: type
+                                });
+                                return type;
+                            }
+                        });
+                    }
+                    return validatedFactory;
+                };
+                var cloneElementWithValidation = function cloneElementWithValidation(element, props, children) {
+                    var newElement = cloneElement.apply(this, arguments);
+                    for(var i = 2; i < arguments.length; i++){
+                        validateChildKeys(arguments[i], newElement.type);
+                    }
+                    validatePropTypes(newElement);
+                    return newElement;
+                };
+                var startTransition = function startTransition(scope, options) {
+                    var prevTransition = ReactCurrentBatchConfig.transition;
+                    ReactCurrentBatchConfig.transition = {};
+                    var currentTransition = ReactCurrentBatchConfig.transition;
+                    {
+                        ReactCurrentBatchConfig.transition._updatedFibers = new Set();
+                    }
+                    try {
+                        scope();
+                    } finally{
+                        ReactCurrentBatchConfig.transition = prevTransition;
+                        {
+                            if (prevTransition === null && currentTransition._updatedFibers) {
+                                var updatedFibersCount = currentTransition._updatedFibers.size;
+                                if (updatedFibersCount > 10) {
+                                    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.");
+                                }
+                                currentTransition._updatedFibers.clear();
+                            }
+                        }
+                    }
+                };
+                var enqueueTask = function enqueueTask(task) {
+                    if (enqueueTaskImpl === null) {
+                        try {
+                            // read require off the module object to get around the bundlers.
+                            // we don't want them to detect a require and bundle a Node polyfill.
+                            var requireString = ("require" + Math.random()).slice(0, 7);
+                            var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
+                            // version of setImmediate, bypassing fake timers if any.
+                            enqueueTaskImpl = nodeRequire.call(module, "timers").setImmediate;
+                        } catch (_err) {
+                            // we're in a browser
+                            // we can't use regular timers because they may still be faked
+                            // so we try MessageChannel+postMessage instead
+                            enqueueTaskImpl = function enqueueTaskImpl(callback) {
+                                {
+                                    if (didWarnAboutMessageChannel === false) {
+                                        didWarnAboutMessageChannel = true;
+                                        if (typeof MessageChannel === "undefined") {
+                                            error("This browser does not have a MessageChannel implementation, " + "so enqueuing tasks via await act(async () => ...) will fail. " + "Please file an issue at https://github.com/facebook/react/issues " + "if you encounter this warning.");
+                                        }
+                                    }
+                                }
+                                var channel = new MessageChannel();
+                                channel.port1.onmessage = callback;
+                                channel.port2.postMessage(undefined);
+                            };
+                        }
+                    }
+                    return enqueueTaskImpl(task);
+                };
+                var act = function act(callback) {
+                    {
+                        // `act` calls can be nested, so we track the depth. This represents the
+                        // number of `act` scopes on the stack.
+                        var prevActScopeDepth = actScopeDepth;
+                        actScopeDepth++;
+                        if (ReactCurrentActQueue.current === null) {
+                            // This is the outermost `act` scope. Initialize the queue. The reconciler
+                            // will detect the queue and use it instead of Scheduler.
+                            ReactCurrentActQueue.current = [];
+                        }
+                        var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
+                        var result;
+                        try {
+                            // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
+                            // set to `true` while the given callback is executed, not for updates
+                            // triggered during an async event, because this is how the legacy
+                            // implementation of `act` behaved.
+                            ReactCurrentActQueue.isBatchingLegacy = true;
+                            result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
+                            // which flushed updates immediately after the scope function exits, even
+                            // if it's an async function.
+                            if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
+                                var queue = ReactCurrentActQueue.current;
+                                if (queue !== null) {
+                                    ReactCurrentActQueue.didScheduleLegacyUpdate = false;
+                                    flushActQueue(queue);
+                                }
+                            }
+                        } catch (error1) {
+                            popActScope(prevActScopeDepth);
+                            throw error1;
+                        } finally{
+                            ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
+                        }
+                        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+                            var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
+                            // for it to resolve before exiting the current scope.
+                            var wasAwaited = false;
+                            var thenable = {
+                                then: function then(resolve, reject) {
+                                    wasAwaited = true;
+                                    thenableResult.then(function(returnValue) {
+                                        popActScope(prevActScopeDepth);
+                                        if (actScopeDepth === 0) {
+                                            // We've exited the outermost act scope. Recursively flush the
+                                            // queue until there's no remaining work.
+                                            recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                                        } else {
+                                            resolve(returnValue);
+                                        }
+                                    }, function(error) {
+                                        // The callback threw an error.
+                                        popActScope(prevActScopeDepth);
+                                        reject(error);
+                                    });
+                                }
+                            };
+                            {
+                                if (!didWarnNoAwaitAct && typeof Promise !== "undefined") {
+                                    // eslint-disable-next-line no-undef
+                                    Promise.resolve().then(function() {}).then(function() {
+                                        if (!wasAwaited) {
+                                            didWarnNoAwaitAct = true;
+                                            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 () => ...);");
+                                        }
+                                    });
+                                }
+                            }
+                            return thenable;
+                        } else {
+                            var returnValue = result; // The callback is not an async function. Exit the current scope
+                            // immediately, without awaiting.
+                            popActScope(prevActScopeDepth);
+                            if (actScopeDepth === 0) {
+                                // Exiting the outermost act scope. Flush the queue.
+                                var _queue = ReactCurrentActQueue.current;
+                                if (_queue !== null) {
+                                    flushActQueue(_queue);
+                                    ReactCurrentActQueue.current = null;
+                                } // Return a thenable. If the user awaits it, we'll flush again in
+                                // case additional work was scheduled by a microtask.
+                                var _thenable = {
+                                    then: function then(resolve, reject) {
+                                        // Confirm we haven't re-entered another `act` scope, in case
+                                        // the user does something weird like await the thenable
+                                        // multiple times.
+                                        if (ReactCurrentActQueue.current === null) {
+                                            // Recursively flush the queue until there's no remaining work.
+                                            ReactCurrentActQueue.current = [];
+                                            recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                                        } else {
+                                            resolve(returnValue);
+                                        }
+                                    }
+                                };
+                                return _thenable;
+                            } else {
+                                // Since we're inside a nested `act` scope, the returned thenable
+                                // immediately resolves. The outer scope will flush the queue.
+                                var _thenable2 = {
+                                    then: function then(resolve, reject) {
+                                        resolve(returnValue);
+                                    }
+                                };
+                                return _thenable2;
+                            }
+                        }
+                    }
+                };
+                var popActScope = function popActScope(prevActScopeDepth) {
+                    {
+                        if (prevActScopeDepth !== actScopeDepth - 1) {
+                            error("You seem to have overlapping act() calls, this is not supported. " + "Be sure to await previous act() calls before making a new one. ");
+                        }
+                        actScopeDepth = prevActScopeDepth;
+                    }
+                };
+                var flushActQueue = function flushActQueue(queue) {
+                    {
+                        if (!isFlushing) {
+                            // Prevent re-entrance.
+                            isFlushing = true;
+                            var i = 0;
+                            try {
+                                for(; i < queue.length; i++){
+                                    var callback = queue[i];
+                                    do {
+                                        callback = callback(true);
+                                    }while (callback !== null);
+                                }
+                                queue.length = 0;
+                            } catch (error) {
+                                // If something throws, leave the remaining callbacks on the queue.
+                                queue = queue.slice(i + 1);
+                                throw error;
+                            } finally{
+                                isFlushing = false;
+                            }
+                        }
+                    }
+                };
+                /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+                    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+                }
+                var ReactVersion = "18.2.0";
+                // ATTENTION
+                // When adding new symbols to this file,
+                // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+                // The Symbol used to tag the ReactElement-like types.
+                var REACT_ELEMENT_TYPE = Symbol.for("react.element");
+                var REACT_PORTAL_TYPE = Symbol.for("react.portal");
+                var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+                var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
+                var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+                var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
+                var REACT_CONTEXT_TYPE = Symbol.for("react.context");
+                var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+                var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
+                var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
+                var REACT_MEMO_TYPE = Symbol.for("react.memo");
+                var REACT_LAZY_TYPE = Symbol.for("react.lazy");
+                var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
+                var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+                var FAUX_ITERATOR_SYMBOL = "@@iterator";
+                /**
+		 * Keeps track of the current dispatcher.
+		 */ var ReactCurrentDispatcher = {
+                    /**
+		   * @internal
+		   * @type {ReactComponent}
+		   */ current: null
+                };
+                /**
+		 * Keeps track of the current batch's configuration such as how long an update
+		 * should suspend for if it needs to.
+		 */ var ReactCurrentBatchConfig = {
+                    transition: null
+                };
+                var ReactCurrentActQueue = {
+                    current: null,
+                    // Used to reproduce behavior of `batchedUpdates` in legacy mode.
+                    isBatchingLegacy: false,
+                    didScheduleLegacyUpdate: false
+                };
+                /**
+		 * Keeps track of the current owner.
+		 *
+		 * The current owner is the component who should own any components that are
+		 * currently being constructed.
+		 */ var ReactCurrentOwner = {
+                    /**
+		   * @internal
+		   * @type {ReactComponent}
+		   */ current: null
+                };
+                var ReactDebugCurrentFrame = {};
+                var currentExtraStackFrame = null;
+                {
+                    ReactDebugCurrentFrame.setExtraStackFrame = function(stack) {
+                        {
+                            currentExtraStackFrame = stack;
+                        }
+                    }; // Stack implementation injected by the current renderer.
+                    ReactDebugCurrentFrame.getCurrentStack = null;
+                    ReactDebugCurrentFrame.getStackAddendum = function() {
+                        var stack = ""; // Add an extra top frame while an element is being validated
+                        if (currentExtraStackFrame) {
+                            stack += currentExtraStackFrame;
+                        } // Delegate to the injected renderer-specific implementation
+                        var impl = ReactDebugCurrentFrame.getCurrentStack;
+                        if (impl) {
+                            stack += impl() || "";
+                        }
+                        return stack;
+                    };
+                }
+                // -----------------------------------------------------------------------------
+                var enableScopeAPI = false; // Experimental Create Event Handle API.
+                var enableCacheElement = false;
+                var enableTransitionTracing = false; // No known bugs, but needs performance testing
+                var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+                // stuff. Intended to enable React core members to more easily debug scheduling
+                // issues in DEV builds.
+                var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+                var ReactSharedInternals = {
+                    ReactCurrentDispatcher: ReactCurrentDispatcher,
+                    ReactCurrentBatchConfig: ReactCurrentBatchConfig,
+                    ReactCurrentOwner: ReactCurrentOwner
+                };
+                {
+                    ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
+                    ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
+                }
+                var didWarnStateUpdateForUnmountedComponent = {};
+                /**
+		 * This is the abstract API for an update queue.
+		 */ var ReactNoopUpdateQueue = {
+                    /**
+		   * Checks whether or not this composite component is mounted.
+		   * @param {ReactClass} publicInstance The instance we want to test.
+		   * @return {boolean} True if mounted, false otherwise.
+		   * @protected
+		   * @final
+		   */ isMounted: function isMounted(publicInstance) {
+                        return false;
+                    },
+                    /**
+		   * Forces an update. This should only be invoked when it is known with
+		   * certainty that we are **not** in a DOM transaction.
+		   *
+		   * You may want to call this when you know that some deeper aspect of the
+		   * component's state has changed but `setState` was not called.
+		   *
+		   * This will not invoke `shouldComponentUpdate`, but it will invoke
+		   * `componentWillUpdate` and `componentDidUpdate`.
+		   *
+		   * @param {ReactClass} publicInstance The instance that should rerender.
+		   * @param {?function} callback Called after component is updated.
+		   * @param {?string} callerName name of the calling function in the public API.
+		   * @internal
+		   */ enqueueForceUpdate: function enqueueForceUpdate(publicInstance, callback, callerName) {
+                        warnNoop(publicInstance, "forceUpdate");
+                    },
+                    /**
+		   * Replaces all of the state. Always use this or `setState` to mutate state.
+		   * You should treat `this.state` as immutable.
+		   *
+		   * There is no guarantee that `this.state` will be immediately updated, so
+		   * accessing `this.state` after calling this method may return the old value.
+		   *
+		   * @param {ReactClass} publicInstance The instance that should rerender.
+		   * @param {object} completeState Next state.
+		   * @param {?function} callback Called after component is updated.
+		   * @param {?string} callerName name of the calling function in the public API.
+		   * @internal
+		   */ enqueueReplaceState: function enqueueReplaceState(publicInstance, completeState, callback, callerName) {
+                        warnNoop(publicInstance, "replaceState");
+                    },
+                    /**
+		   * Sets a subset of the state. This only exists because _pendingState is
+		   * internal. This provides a merging strategy that is not available to deep
+		   * properties which is confusing. TODO: Expose pendingState or don't use it
+		   * during the merge.
+		   *
+		   * @param {ReactClass} publicInstance The instance that should rerender.
+		   * @param {object} partialState Next partial state to be merged with state.
+		   * @param {?function} callback Called after component is updated.
+		   * @param {?string} Name of the calling function in the public API.
+		   * @internal
+		   */ enqueueSetState: function enqueueSetState(publicInstance, partialState, callback, callerName) {
+                        warnNoop(publicInstance, "setState");
+                    }
+                };
+                var assign = Object.assign;
+                var emptyObject = {};
+                {
+                    Object.freeze(emptyObject);
+                }
+                Component.prototype.isReactComponent = {};
+                /**
+		 * Sets a subset of the state. Always use this to mutate
+		 * state. You should treat `this.state` as immutable.
+		 *
+		 * There is no guarantee that `this.state` will be immediately updated, so
+		 * accessing `this.state` after calling this method may return the old value.
+		 *
+		 * There is no guarantee that calls to `setState` will run synchronously,
+		 * as they may eventually be batched together.  You can provide an optional
+		 * callback that will be executed when the call to setState is actually
+		 * completed.
+		 *
+		 * When a function is provided to setState, it will be called at some point in
+		 * the future (not synchronously). It will be called with the up to date
+		 * component arguments (state, props, context). These values can be different
+		 * from this.* because your function may be called after receiveProps but before
+		 * shouldComponentUpdate, and this new state, props, and context will not yet be
+		 * assigned to this.
+		 *
+		 * @param {object|function} partialState Next partial state or function to
+		 *        produce next partial state to be merged with current state.
+		 * @param {?function} callback Called after state is updated.
+		 * @final
+		 * @protected
+		 */ Component.prototype.setState = function(partialState, callback) {
+                    if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null) {
+                        throw new Error("setState(...): takes an object of state variables to update or a " + "function which returns an object of state variables.");
+                    }
+                    this.updater.enqueueSetState(this, partialState, callback, "setState");
+                };
+                /**
+		 * Forces an update. This should only be invoked when it is known with
+		 * certainty that we are **not** in a DOM transaction.
+		 *
+		 * You may want to call this when you know that some deeper aspect of the
+		 * component's state has changed but `setState` was not called.
+		 *
+		 * This will not invoke `shouldComponentUpdate`, but it will invoke
+		 * `componentWillUpdate` and `componentDidUpdate`.
+		 *
+		 * @param {?function} callback Called after update is complete.
+		 * @final
+		 * @protected
+		 */ Component.prototype.forceUpdate = function(callback) {
+                    this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+                };
+                /**
+		 * Deprecated APIs. These APIs used to exist on classic React classes but since
+		 * we would like to deprecate them, we're not going to move them over to this
+		 * modern base class. Instead, we define a getter that warns if it's accessed.
+		 */ {
+                    var deprecatedAPIs = {
+                        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)."
+                        ]
+                    };
+                    var defineDeprecationWarning = function defineDeprecationWarning(methodName, info) {
+                        Object.defineProperty(Component.prototype, methodName, {
+                            get: function get() {
+                                warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+                                return undefined;
+                            }
+                        });
+                    };
+                    for(var fnName in deprecatedAPIs){
+                        if (deprecatedAPIs.hasOwnProperty(fnName)) {
+                            defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+                        }
+                    }
+                }
+                ComponentDummy.prototype = Component.prototype;
+                var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+                pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+                assign(pureComponentPrototype, Component.prototype);
+                pureComponentPrototype.isPureReactComponent = true;
+                var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+                function getComponentNameFromType(type) {
+                    if (type == null) {
+                        // Host root, text node or just invalid type.
+                        return null;
+                    }
+                    {
+                        if (typeof type.tag === "number") {
+                            error("Received an unexpected object in getComponentNameFromType(). " + "This is likely a bug in React. Please file an issue.");
+                        }
+                    }
+                    if (typeof type === "function") {
+                        return type.displayName || type.name || null;
+                    }
+                    if (typeof type === "string") {
+                        return type;
+                    }
+                    switch(type){
+                        case REACT_FRAGMENT_TYPE:
+                            return "Fragment";
+                        case REACT_PORTAL_TYPE:
+                            return "Portal";
+                        case REACT_PROFILER_TYPE:
+                            return "Profiler";
+                        case REACT_STRICT_MODE_TYPE:
+                            return "StrictMode";
+                        case REACT_SUSPENSE_TYPE:
+                            return "Suspense";
+                        case REACT_SUSPENSE_LIST_TYPE:
+                            return "SuspenseList";
+                    }
+                    if (typeof type === "object") {
+                        switch(type.$$typeof){
+                            case REACT_CONTEXT_TYPE:
+                                var context = type;
+                                return getContextName(context) + ".Consumer";
+                            case REACT_PROVIDER_TYPE:
+                                var provider = type;
+                                return getContextName(provider._context) + ".Provider";
+                            case REACT_FORWARD_REF_TYPE:
+                                return getWrappedName(type, type.render, "ForwardRef");
+                            case REACT_MEMO_TYPE:
+                                var outerName = type.displayName || null;
+                                if (outerName !== null) {
+                                    return outerName;
+                                }
+                                return getComponentNameFromType(type.type) || "Memo";
+                            case REACT_LAZY_TYPE:
+                                {
+                                    var lazyComponent = type;
+                                    var payload = lazyComponent._payload;
+                                    var init = lazyComponent._init;
+                                    try {
+                                        return getComponentNameFromType(init(payload));
+                                    } catch (x) {
+                                        return null;
+                                    }
+                                }
+                        }
+                    }
+                    return null;
+                }
+                var hasOwnProperty = Object.prototype.hasOwnProperty;
+                var RESERVED_PROPS = {
+                    key: true,
+                    ref: true,
+                    __self: true,
+                    __source: true
+                };
+                var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
+                {
+                    didWarnAboutStringRefs = {};
+                }
+                /**
+		 * Factory method to create a new React element. This no longer adheres to
+		 * the class pattern, so do not use new to call it. Also, instanceof check
+		 * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+		 * if something is a React Element.
+		 *
+		 * @param {*} type
+		 * @param {*} props
+		 * @param {*} key
+		 * @param {string|object} ref
+		 * @param {*} owner
+		 * @param {*} self A *temporary* helper to detect places where `this` is
+		 * different from the `owner` when React.createElement is called, so that we
+		 * can warn. We want to get rid of owner and replace string `ref`s with arrow
+		 * functions, and as long as `this` and owner are the same, there will be no
+		 * change in behavior.
+		 * @param {*} source An annotation object (added by a transpiler or otherwise)
+		 * indicating filename, line number, and/or other information.
+		 * @internal
+		 */ var ReactElement = function ReactElement(type, key, ref, self, source, owner, props) {
+                    var element = {
+                        // This tag allows us to uniquely identify this as a React Element
+                        $$typeof: REACT_ELEMENT_TYPE,
+                        // Built-in properties that belong on the element
+                        type: type,
+                        key: key,
+                        ref: ref,
+                        props: props,
+                        // Record the component responsible for creating this element.
+                        _owner: owner
+                    };
+                    {
+                        // The validation flag is currently mutative. We put it on
+                        // an external backing store so that we can freeze the whole object.
+                        // This can be replaced with a WeakMap once they are implemented in
+                        // commonly used development environments.
+                        element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
+                        // the validation flag non-enumerable (where possible, which should
+                        // include every environment we run tests in), so the test framework
+                        // ignores it.
+                        Object.defineProperty(element._store, "validated", {
+                            configurable: false,
+                            enumerable: false,
+                            writable: true,
+                            value: false
+                        }); // self and source are DEV only properties.
+                        Object.defineProperty(element, "_self", {
+                            configurable: false,
+                            enumerable: false,
+                            writable: false,
+                            value: self
+                        }); // Two elements created in two different places should be considered
+                        // equal for testing purposes and therefore we hide it from enumeration.
+                        Object.defineProperty(element, "_source", {
+                            configurable: false,
+                            enumerable: false,
+                            writable: false,
+                            value: source
+                        });
+                        if (Object.freeze) {
+                            Object.freeze(element.props);
+                            Object.freeze(element);
+                        }
+                    }
+                    return element;
+                };
+                var SEPARATOR = ".";
+                var SUBSEPARATOR = ":";
+                /**
+		 * TODO: Test that a single child and an array with one item have the same key
+		 * pattern.
+		 */ var didWarnAboutMaps = false;
+                var userProvidedKeyEscapeRegex = /\/+/g;
+                function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+                    var type = typeof children === "undefined" ? "undefined" : _typeof(children);
+                    if (type === "undefined" || type === "boolean") {
+                        // All of the above are perceived as null.
+                        children = null;
+                    }
+                    var invokeCallback = false;
+                    if (children === null) {
+                        invokeCallback = true;
+                    } else {
+                        switch(type){
+                            case "string":
+                            case "number":
+                                invokeCallback = true;
+                                break;
+                            case "object":
+                                switch(children.$$typeof){
+                                    case REACT_ELEMENT_TYPE:
+                                    case REACT_PORTAL_TYPE:
+                                        invokeCallback = true;
+                                }
+                        }
+                    }
+                    if (invokeCallback) {
+                        var _child = children;
+                        var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array
+                        // so that it's consistent if the number of children grows:
+                        var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
+                        if (isArray(mappedChild)) {
+                            var escapedChildKey = "";
+                            if (childKey != null) {
+                                escapedChildKey = escapeUserProvidedKey(childKey) + "/";
+                            }
+                            mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) {
+                                return c;
+                            });
+                        } else if (mappedChild != null) {
+                            if (isValidElement(mappedChild)) {
+                                {
+                                    // The `if` statement here prevents auto-disabling of the safe
+                                    // coercion ESLint rule, so we must manually disable it below.
+                                    // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
+                                    if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) {
+                                        checkKeyStringCoercion(mappedChild.key);
+                                    }
+                                }
+                                mappedChild = cloneAndReplaceKey(mappedChild, // traverseAllChildren used to do for objects as children
+                                escapedPrefix + (mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // eslint-disable-next-line react-internal/safe-string-coercion
+                                escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + childKey);
+                            }
+                            array.push(mappedChild);
+                        }
+                        return 1;
+                    }
+                    var child;
+                    var nextName;
+                    var subtreeCount = 0; // Count of children found in the current subtree.
+                    var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+                    if (isArray(children)) {
+                        for(var i = 0; i < children.length; i++){
+                            child = children[i];
+                            nextName = nextNamePrefix + getElementKey(child, i);
+                            subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+                        }
+                    } else {
+                        var iteratorFn = getIteratorFn(children);
+                        if (typeof iteratorFn === "function") {
+                            var iterableChildren = children;
+                            {
+                                // Warn about using Maps as children
+                                if (iteratorFn === iterableChildren.entries) {
+                                    if (!didWarnAboutMaps) {
+                                        warn("Using Maps as children is not supported. " + "Use an array of keyed ReactElements instead.");
+                                    }
+                                    didWarnAboutMaps = true;
+                                }
+                            }
+                            var iterator = iteratorFn.call(iterableChildren);
+                            var step;
+                            var ii = 0;
+                            while(!(step = iterator.next()).done){
+                                child = step.value;
+                                nextName = nextNamePrefix + getElementKey(child, ii++);
+                                subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+                            }
+                        } else if (type === "object") {
+                            // eslint-disable-next-line react-internal/safe-string-coercion
+                            var childrenString = String(children);
+                            throw new Error("Objects are not valid as a React child (found: " + (childrenString === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). " + "If you meant to render a collection of children, use an array " + "instead.");
+                        }
+                    }
+                    return subtreeCount;
+                }
+                var Uninitialized = -1;
+                var Pending = 0;
+                var Resolved = 1;
+                var Rejected = 2;
+                var REACT_MODULE_REFERENCE;
+                {
+                    REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
+                }
+                // Helpers to patch console.logs to avoid logging during side-effect free
+                // replaying on render function. This currently only patches the object
+                // lazily which won't cover if the log function was extracted eagerly.
+                // We could also eagerly patch the method.
+                var disabledDepth = 0;
+                var prevLog;
+                var prevInfo;
+                var prevWarn;
+                var prevError;
+                var prevGroup;
+                var prevGroupCollapsed;
+                var prevGroupEnd;
+                disabledLog.__reactDisabledLog = true;
+                var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+                var prefix;
+                var reentry = false;
+                var componentFrameCache;
+                {
+                    var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+                    componentFrameCache = new PossiblyWeakMap();
+                }
+                function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+                    if (type == null) {
+                        return "";
+                    }
+                    if (typeof type === "function") {
+                        {
+                            return describeNativeComponentFrame(type, shouldConstruct(type));
+                        }
+                    }
+                    if (typeof type === "string") {
+                        return describeBuiltInComponentFrame(type);
+                    }
+                    switch(type){
+                        case REACT_SUSPENSE_TYPE:
+                            return describeBuiltInComponentFrame("Suspense");
+                        case REACT_SUSPENSE_LIST_TYPE:
+                            return describeBuiltInComponentFrame("SuspenseList");
+                    }
+                    if (typeof type === "object") {
+                        switch(type.$$typeof){
+                            case REACT_FORWARD_REF_TYPE:
+                                return describeFunctionComponentFrame(type.render);
+                            case REACT_MEMO_TYPE:
+                                // Memo may contain any component type so we recursively resolve it.
+                                return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+                            case REACT_LAZY_TYPE:
+                                {
+                                    var lazyComponent = type;
+                                    var payload = lazyComponent._payload;
+                                    var init = lazyComponent._init;
+                                    try {
+                                        // Lazy may contain any component type so we recursively resolve it.
+                                        return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+                                    } catch (x) {}
+                                }
+                        }
+                    }
+                    return "";
+                }
+                var loggedTypeFailures = {};
+                var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+                var propTypesMisspellWarningShown;
+                {
+                    propTypesMisspellWarningShown = false;
+                }
+                /**
+		 * Warn if there's no key explicitly set on dynamic arrays of children or
+		 * object keys are not valid. This allows us to keep track of children between
+		 * updates.
+		 */ var ownerHasKeyUseWarning = {};
+                var didWarnAboutDeprecatedCreateFactory = false;
+                var didWarnAboutMessageChannel = false;
+                var enqueueTaskImpl = null;
+                var actScopeDepth = 0;
+                var didWarnNoAwaitAct = false;
+                function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+                    {
+                        var queue = ReactCurrentActQueue.current;
+                        if (queue !== null) {
+                            try {
+                                flushActQueue(queue);
+                                enqueueTask(function() {
+                                    if (queue.length === 0) {
+                                        // No additional work was scheduled. Finish.
+                                        ReactCurrentActQueue.current = null;
+                                        resolve(returnValue);
+                                    } else {
+                                        // Keep flushing work until there's none left.
+                                        recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                                    }
+                                });
+                            } catch (error) {
+                                reject(error);
+                            }
+                        } else {
+                            resolve(returnValue);
+                        }
+                    }
+                }
+                var isFlushing = false;
+                var createElement$1 = createElementWithValidation;
+                var cloneElement$1 = cloneElementWithValidation;
+                var createFactory = createFactoryWithValidation;
+                var Children = {
+                    map: mapChildren,
+                    forEach: forEachChildren,
+                    count: countChildren,
+                    toArray: toArray,
+                    only: onlyChild
+                };
+                exports.Children = Children;
+                exports.Component = Component;
+                exports.Fragment = REACT_FRAGMENT_TYPE;
+                exports.Profiler = REACT_PROFILER_TYPE;
+                exports.PureComponent = PureComponent;
+                exports.StrictMode = REACT_STRICT_MODE_TYPE;
+                exports.Suspense = REACT_SUSPENSE_TYPE;
+                exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+                exports.cloneElement = cloneElement$1;
+                exports.createContext = createContext;
+                exports.createElement = createElement$1;
+                exports.createFactory = createFactory;
+                exports.createRef = createRef;
+                exports.forwardRef = forwardRef;
+                exports.isValidElement = isValidElement;
+                exports.lazy = lazy;
+                exports.memo = memo;
+                exports.startTransition = startTransition;
+                exports.unstable_act = act;
+                exports.useCallback = useCallback;
+                exports.useContext = useContext;
+                exports.useDebugValue = useDebugValue;
+                exports.useDeferredValue = useDeferredValue;
+                exports.useEffect = useEffect;
+                exports.useId = useId;
+                exports.useImperativeHandle = useImperativeHandle;
+                exports.useInsertionEffect = useInsertionEffect;
+                exports.useLayoutEffect = useLayoutEffect;
+                exports.useMemo = useMemo;
+                exports.useReducer = useReducer;
+                exports.useRef = useRef;
+                exports.useState = useState;
+                exports.useSyncExternalStore = useSyncExternalStore;
+                exports.useTransition = useTransition;
+                exports.version = ReactVersion;
+                /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+                    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+                }
+            })();
+        }
+    })(react_development, react_development.exports);
+    return react_development.exports;
+}
+
+(function(module) {
+    if (process.env.NODE_ENV === "production") {
+        module.exports = requireReact_production_min();
+    } else {
+        module.exports = requireReact_development();
+    }
+})(react);
+var React = /*@__PURE__*/ getDefaultExportFromCjs(react.exports);
+
+function _extends$1() {
+    _extends$1 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$1.apply(this, arguments);
+}
+function Box(param) {
+    var children = param.children, smallText = param.smallText, padding = param.padding, flex = param.flex, style = param.style;
+    var styles = _extends$1({
+        flex: flex
+    }, layoutPropsToStyles({
+        padding: padding
+    }), style);
+    var className = classList({
+        "jb-box": true,
+        "jbx-small-text": smallText
+    });
+    return /*#__PURE__*/ React.createElement("div", {
+        className: className,
+        style: styles
+    }, children);
+}
+
+// @ts-nocheck
+var PROJECT_DATA = [
+    {
+        name: "PINTR",
+        description: "Tool that turns your images into plotter-like line drawings",
+        url: "https://javier.xyz/pintr/"
+    },
+    {
+        name: "Visual Center",
+        description: "Tool that help you visually center objects in a container",
+        url: "https://javier.xyz/visual-center/"
+    },
+    {
+        name: "Brutalita",
+        description: "Grid based font editor and font. Create fonts in the browser and export OpenType files",
+        url: "https://brutalita.com/"
+    },
+    {
+        name: "Morphin",
+        description: "Create animated CSS transitions. Add sprites and get the code ready to paste in your site",
+        url: "https://javier.xyz/morphin/"
+    },
+    {
+        name: "Droste Creator",
+        description: "Create recursive images with the droste effect",
+        url: "https://javier.xyz/droste-creator/"
+    },
+    {
+        name: "Sombras.app",
+        description: "Create art with shadows. Draw shadows and get 3D objects that project them.",
+        url: "https://sombras.app/"
+    },
+    {
+        name: "Cohesive Colors",
+        description: "Tool that can help you to create cohesive color palettes",
+        url: "https://javier.xyz/cohesive-colors/"
+    }
+];
+var projects = PROJECT_DATA.filter(function(project) {
+    return !project.url.includes(document.location.pathname);
+});
+var projectIndex = PROJECT_DATA.findIndex(function(project) {
+    return !project.url.includes(document.location.pathname);
+});
+var seed = Math.floor(new Date().getTime() / (60 * 60 * 1000)) + projectIndex;
+function MoreExperiments() {
+    var items = new Array(4).fill("").map(function(_0, idx) {
+        var project = projects[(seed + idx) % projects.length];
+        return /*#__PURE__*/ React.createElement(Li, {
+            key: project.url
+        }, /*#__PURE__*/ React.createElement(A, {
+            href: project.url
+        }, project.name), ", ", project.description, ".");
+    });
+    return /*#__PURE__*/ React.createElement(react.exports.Fragment, null, /*#__PURE__*/ React.createElement(Text, null, "More experiments"), /*#__PURE__*/ React.createElement(Space, {
+        h: 1
+    }), /*#__PURE__*/ React.createElement(Ul, null, items));
+}
+
+// @ts-nocheck
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+var SIZE = getSettings().size;
+var BASE_RADIUS = SIZE / 3;
+var BASE_FONT_SIZE = SIZE;
+function getSettings() {
+    var sizeSrc = getComputedStyle(document.documentElement).getPropertyValue("--size");
+    return {
+        size: parseInt(sizeSrc)
+    };
+}
+function classList(classes) {
+    if (Array.isArray(classes)) {
+        return classes.filter(function(e) {
+            return e;
+        }).join(" ");
+    } else {
+        return Object.keys(classes).filter(function(e) {
+            return classes[e];
+        }).join(" ");
+    }
+}
+function layoutPropsToStyles(param) {
+    var padding = param.padding;
+    var newStyles = {};
+    if (padding) {
+        newStyles.padding = "" + getSettings().size * padding + "px";
+    }
+    return newStyles;
+}
+function Component(className, styleSrc, config) {
+    if (styleSrc === void 0) styleSrc = {};
+    if (config === void 0) config = {};
+    var _element = config.element, element = _element === void 0 ? "div" : _element, styleProps = config.styleProps;
+    return function MakeComponent(_param) {
+        var children = _param.children, _style = _param.style, style = _style === void 0 ? {} : _style, props = _objectWithoutPropertiesLoose(_param, [
+            "children",
+            "style"
+        ]);
+        var passProps = styleProps ? Object.keys(props).filter(function(e) {
+            return !styleProps.includes(e);
+        }).reduce(function(acc, p) {
+            acc[p] = props[p];
+            return acc;
+        }, {}) : props;
+        var calculatedStyle = typeof styleSrc === "function" ? styleSrc(props) : styleSrc;
+        return /*#__PURE__*/ React.createElement(element, _extends({
+            className: className,
+            style: _extends({}, style, calculatedStyle)
+        }, passProps), children);
+    };
+}
+var Container = Component("jbx-container");
+var Text = Component("jbx-text");
+var SmallText = Component("jbx-small-text");
+var Button = Component("jbx-button", {}, {
+    element: "button"
+});
+var Input = Component("jbx-input", null, {
+    element: "input"
+});
+var Range = Component("jbx-range", null, {
+    element: "input"
+});
+var HeaderH1 = Component("jbx-h" + 1, null, {
+    element: "h1"
+});
+var HeaderH2 = Component("jbx-h" + 2, null, {
+    element: "h2"
+});
+var HeaderH3 = Component("jbx-h" + 3, null, {
+    element: "h3"
+});
+var HeaderH4 = Component("jbx-h" + 4, null, {
+    element: "h4"
+});
+var HR = Component("jbx-hr", null, {
+    element: "hr"
+});
+var MainHeader = function MainHeader(param) {
+    var children = param.children, style = param.style;
+    var content = String(children).split(" ");
+    return /*#__PURE__*/ React.createElement(react.exports.Fragment, {}, content.map(function(word) {
+        return /*#__PURE__*/ React.createElement(HeaderH1, {
+            key: word,
+            style: _extends({
+                display: "inline-block",
+                width: "auto",
+                padding: "6px",
+                margin: 0,
+                backgroundColor: "var(--accent-color)"
+            }, style)
+        }, word);
+    }));
+};
+var A = Component("jbx-a", null, {
+    element: "a"
+});
+var Space = Component("jbx-space", function(props) {
+    return {
+        display: props.inline ? "inline-block" : "block",
+        height: "" + SIZE * props.h + "px",
+        width: "" + SIZE * props.w + "px"
+    };
+});
+var Inline = Component("jbx-inline", function(param) {
+    var v = param.v, h = param.h, gap = param.gap, _wrap = param.wrap, wrap = _wrap === void 0 ? false : _wrap;
+    return {
+        marginLeft: "" + h * SIZE + "px",
+        marginRight: "" + h * SIZE + "px",
+        marginTop: "" + v * SIZE + "px",
+        marginBottom: "" + v * SIZE + "px",
+        gap: "" + gap * SIZE + "px",
+        flexWrap: wrap ? "wrap" : "no-wrap"
+    };
+});
+var Stack = Component("jbx-stack", function(param) {
+    var v = param.v, h = param.h, gap = param.gap;
+    return {
+        marginLeft: "" + h * SIZE + "px",
+        marginRight: "" + h * SIZE + "px",
+        marginTop: "" + v * SIZE + "px",
+        marginBottom: "" + v * SIZE + "px",
+        gap: "" + gap * SIZE + "px"
+    };
+});
+var Dropzone = Component("jbx-dropzone");
+var Ul = Component("jbx-ul", {
+    margin: 0,
+    padding: "0 0 0 " + BASE_FONT_SIZE / 4 + "px"
+}, {
+    element: "ul"
+});
+var Li = Component("jbx-li", {
+    margin: "0 0 0 " + SIZE + "px",
+    padding: "" + SIZE / 4 + "px 0"
+}, {
+    element: "li"
+});
+var Tabs = Component("jbx-tabs");
+var Tab = Component("jbx-tabs--tab", function(param) {
+    var info = param.info, active = param.active;
+    return {
+        userSelect: "none",
+        cursor: "pointer",
+        backgroundColor: active ? "#000" : info ? "#fff" : "#ecf0f1",
+        color: active ? "#fff" : "#000",
+        padding: SIZE / 2,
+        paddingLeft: info ? 0 : SIZE / 2
+    };
+}, {
+    styleProps: [
+        "info",
+        "active"
+    ]
+});
+var CodeSnippet = Component("jbx-code-snippet", null, {
+    element: "pre"
+});
+var CodeTextarea = Component("jbx-code-area", null, {
+    element: "textarea"
+});
+var CheckboxHidden = Component("jbx-checkbox-hidden", function(param) {
+    var checked = param.checked;
+    return {
+        height: SIZE * 2 - 4,
+        width: SIZE * 2 - 4,
+        paddingTop: 2,
+        paddingLeft: 2,
+        backgroundColor: checked ? "var(--accent-color)" : "white",
+        borderRadius: BASE_RADIUS,
+        boxShadow: checked ? "inset rgba(0, 0, 0, 0.07) 0 0 0 1px" : "inset rgba(0, 0, 0, 0.33) 0 0 0 1.5px",
+        cursor: "pointer"
+    };
+});
+var Checkbox = function Checkbox(param) {
+    var label = param.label, checked = param.checked, onChange = param.onChange;
+    return /*#__PURE__*/ React.createElement(Inline, {
+        onClick: function() {
+            if (onChange) {
+                onChange(!checked);
+            }
+        },
+        style: {
+            alignItems: "center",
+            cursor: "pointer"
+        }
+    }, [
+        /*#__PURE__*/ React.createElement(CheckboxHidden, {
+            key: 0,
+            checked: checked
+        }, /*#__PURE__*/ React.createElement("svg", {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: SIZE * 2 - 8,
+            height: SIZE * 2 - 8,
+            fill: "none",
+            stroke: "currentColor",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: "2",
+            className: "feather feather-check",
+            viewBox: "0 0 24 24",
+            color: checked ? "white" : "#ddd"
+        }, /*#__PURE__*/ React.createElement("path", {
+            d: "M20 6L9 17 4 12"
+        }))),
+        /*#__PURE__*/ React.createElement(Space, {
+            key: 1,
+            w: 0.5
+        }),
+        /*#__PURE__*/ React.createElement(Text, {
+            key: 2,
+            style: {
+                userSelect: "none"
+            }
+        }, label)
+    ]);
+};
+function Bullet(param) {
+    var value = param.value;
+    return /*#__PURE__*/ React.createElement("div", {
+        className: "jbx-bullet-container"
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: "jbx-bullet"
+    }, value));
+}
+
+exports.A = A;
+exports.Box = Box;
+exports.Bullet = Bullet;
+exports.Button = Button;
+exports.Checkbox = Checkbox;
+exports.CheckboxHidden = CheckboxHidden;
+exports.CodeSnippet = CodeSnippet;
+exports.CodeTextarea = CodeTextarea;
+exports.Component = Component;
+exports.Container = Container;
+exports.Dropzone = Dropzone;
+exports.HR = HR;
+exports.HeaderH1 = HeaderH1;
+exports.HeaderH2 = HeaderH2;
+exports.HeaderH3 = HeaderH3;
+exports.HeaderH4 = HeaderH4;
+exports.Inline = Inline;
+exports.Input = Input;
+exports.Li = Li;
+exports.MainHeader = MainHeader;
+exports.MoreExperiments = MoreExperiments;
+exports.Range = Range;
+exports.SmallText = SmallText;
+exports.Space = Space;
+exports.Stack = Stack;
+exports.Tab = Tab;
+exports.Tabs = Tabs;
+exports.Text = Text;
+exports.Ul = Ul;
+exports.classList = classList;
+exports.getSettings = getSettings;
+exports.layoutPropsToStyles = layoutPropsToStyles;