jbx 2.5.0 → 2.7.0

package/dist/{index.esm.js → index.js}

@@ -1,3 +1,4 @@
+'use strict';
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -6,39 +7,59 @@ 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 (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;
+    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) {
+    }
+    var B = {
+        isMounted: function() {
+            return !1;
+        },
+        enqueueForceUpdate: function() {},
+        enqueueReplaceState: function() {},
+        enqueueSetState: function() {}
+    }, C = Object.assign, D = {};
+    function E(a, b, e) {
         this.props = a;
         this.context = b;
         this.refs = D;
         this.updater = e || B;
+    }
+    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");
     };
-    var F = function F() {};
-    var G = function G(a, b, e) {
+    function F() {}
+    F.prototype = E.prototype;
+    function G(a, b, e) {
         this.props = a;
         this.context = b;
         this.refs = D;
         this.updater = e || B;
+    }
+    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 M = function M(a, b, e) {
+    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;
@@ -56,8 +77,8 @@ function requireReact_production_min() {
             props: c,
             _owner: K.current
         };
-    };
-    var N = function N(a, b) {
+    }
+    function N(a, b) {
         return {
             $$typeof: l,
             type: a.type,
@@ -66,11 +87,11 @@ function requireReact_production_min() {
             props: a.props,
             _owner: a._owner
         };
-    };
-    var O = function O(a) {
+    }
+    function O(a) {
         return "object" === typeof a && null !== a && a.$$typeof === l;
-    };
-    var escape = function escape(a) {
+    }
+    function escape(a) {
         var b = {
             "=": "=0",
             ":": "=2"
@@ -78,67 +99,13 @@ function requireReact_production_min() {
         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 Q(a, b) {
+        return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+    }
     function R(a, b, e, d, c) {
-        var k = typeof a === "undefined" ? "undefined" : _typeof$1(a);
+        var k = typeof a;
         if ("undefined" === k || "boolean" === k) a = null;
         var h = !1;
         if (null === a) h = !0;
@@ -168,6 +135,28 @@ function requireReact_production_min() {
         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;
     }
+    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;
+    }
+    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;
+    }
     var U = {
         current: null
     }, V = {
@@ -179,24 +168,24 @@ function requireReact_production_min() {
     };
     react_production_min.Children = {
         map: S,
-        forEach: function forEach(a, b, e) {
+        forEach: function(a, b, e) {
             S(a, function() {
                 b.apply(this, arguments);
             }, e);
         },
-        count: function count(a) {
+        count: function(a) {
             var b = 0;
             S(a, function() {
                 b++;
             });
             return b;
         },
-        toArray: function toArray(a) {
+        toArray: function(a) {
             return S(a, function(a) {
                 return a;
             }) || [];
         },
-        only: function only(a) {
+        only: function(a) {
             if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
             return a;
         }
@@ -346,25 +335,6 @@ function requireReact_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;
@@ -372,22 +342,114 @@ function requireReact_development() {
     (function(module, exports) {
         if (process.env.NODE_ENV !== "production") {
             (function() {
-                var getIteratorFn = function getIteratorFn(maybeIterable) {
-                    if (maybeIterable === null || typeof maybeIterable !== "object") {
+                /* 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';
+                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") {
+                    if (typeof maybeIterator === 'function') {
                         return maybeIterator;
                     }
                     return null;
+                }
+                /**
+		 * Keeps track of the current dispatcher.
+		 */ var ReactCurrentDispatcher = {
+                    /**
+		   * @internal
+		   * @type {ReactComponent}
+		   */ current: null
                 };
-                var setExtraStackFrame = function setExtraStackFrame(stack) {
+                /**
+		 * 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;
+                function setExtraStackFrame(stack) {
                     {
                         currentExtraStackFrame = stack;
                     }
+                }
+                {
+                    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
                 };
-                var warn = // by calls to these methods by a Babel plugin.
+                {
+                    ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
+                    ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
+                }
+                // 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.
@@ -397,28 +459,28 @@ function requireReact_development() {
                             for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
                                 args[_key - 1] = arguments[_key];
                             }
-                            printWarning("warn", format, args);
+                            printWarning('warn', format, args);
                         }
                     }
-                };
-                var error = function error(format) {
+                }
+                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);
+                            printWarning('error', format, args);
                         }
                     }
-                };
-                var printWarning = function printWarning(level, format, args) {
+                }
+                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";
+                        if (stack !== '') {
+                            format += '%s';
                             args = args.concat([
                                 stack
                             ]);
@@ -426,25 +488,90 @@ function requireReact_development() {
                         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
+                        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 didWarnStateUpdateForUnmountedComponent = {};
+                function warnNoop(publicInstance, callerName) {
                     {
                         var _constructor = publicInstance.constructor;
-                        var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass";
+                        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);
+                        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;
                     }
+                }
+                /**
+		 * 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(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(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(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(publicInstance, partialState, callback, callerName) {
+                        warnNoop(publicInstance, 'setState');
+                    }
                 };
-                var Component = /**
+                var assign = Object.assign;
+                var emptyObject = {};
+                {
+                    Object.freeze(emptyObject);
+                }
+                /**
 		 * Base class helpers for the updating state of a component.
 		 */ function Component(props, context, updater) {
                     this.props = props;
@@ -452,17 +579,98 @@ function requireReact_development() {
                     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;
+                }
+                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(methodName, info) {
+                        Object.defineProperty(Component.prototype, methodName, {
+                            get: function() {
+                                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]);
+                        }
+                    }
+                }
+                function ComponentDummy() {}
+                ComponentDummy.prototype = Component.prototype;
+                /**
+		 * 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
+                }
+                var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+                pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+                assign(pureComponentPrototype, Component.prototype);
+                pureComponentPrototype.isPureReactComponent = true;
+                // an immutable object with a single mutable value
                 function createRef() {
                     var refObject = {
                         current: null
@@ -471,11 +679,12 @@ function requireReact_development() {
                         Object.seal(refObject);
                     }
                     return refObject;
-                };
-                var isArray = function isArray(a) {
+                }
+                var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+                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.
 		 *
@@ -487,13 +696,12 @@ function requireReact_development() {
                 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";
+                        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) {
+                function willCoercionThrow(value) {
                     {
                         try {
                             testStringCoercion(value);
@@ -502,8 +710,8 @@ function requireReact_development() {
                             return true;
                         }
                     }
-                };
-                var testStringCoercion = function testStringCoercion(value) {
+                }
+                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
@@ -527,93 +735,229 @@ function requireReact_development() {
                     // ancestor components where the exception happened.
                     //
                     // eslint-disable-next-line react-internal/safe-string-coercion
-                    return "" + value;
-                };
-                var checkKeyStringCoercion = function checkKeyStringCoercion(value) {
+                    return '' + value;
+                }
+                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));
+                            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) {
+                }
+                function getWrappedName(outerType, innerType, wrapperName) {
                     var displayName = outerType.displayName;
                     if (displayName) {
                         return displayName;
                     }
-                    var functionName = innerType.displayName || innerType.name || "";
-                    return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
+                    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";
+                function getContextName(type) {
+                    return type.displayName || 'Context';
                 } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
-                ;
-                var hasValidRef = function hasValidRef(config) {
+                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 = {};
+                }
+                function hasValidRef(config) {
                     {
-                        if (hasOwnProperty.call(config, "ref")) {
-                            var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
+                        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) {
+                }
+                function hasValidKey(config) {
                     {
-                        if (hasOwnProperty.call(config, "key")) {
-                            var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+                        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() {
+                }
+                function defineKeyPropWarningGetter(props, displayName) {
+                    var warnAboutAccessingKey = function() {
                         {
                             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);
+                                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", {
+                    Object.defineProperty(props, 'key', {
                         get: warnAboutAccessingKey,
                         configurable: true
                     });
-                };
-                var defineRefPropWarningGetter = function defineRefPropWarningGetter(props, displayName) {
-                    var warnAboutAccessingRef = function warnAboutAccessingRef() {
+                }
+                function defineRefPropWarningGetter(props, displayName) {
+                    var warnAboutAccessingRef = function() {
                         {
                             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);
+                                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", {
+                    Object.defineProperty(props, 'ref', {
                         get: warnAboutAccessingRef,
                         configurable: true
                     });
-                };
-                var warnIfStringRefCannotBeAutoConverted = function warnIfStringRefCannotBeAutoConverted(config) {
+                }
+                function warnIfStringRefCannotBeAutoConverted(config) {
                     {
-                        if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
+                        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);
+                                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;
                             }
                         }
                     }
+                }
+                /**
+		 * 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(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 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) {
@@ -634,7 +978,7 @@ function requireReact_development() {
                             {
                                 checkKeyStringCoercion(config.key);
                             }
-                            key = "" + 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
@@ -670,7 +1014,7 @@ function requireReact_development() {
                     }
                     {
                         if (key || ref) {
-                            var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
+                            var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
                             if (key) {
                                 defineKeyPropWarningGetter(props, displayName);
                             }
@@ -680,12 +1024,12 @@ function requireReact_development() {
                         }
                     }
                     return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
-                };
-                var cloneAndReplaceKey = function cloneAndReplaceKey(oldElement, newKey) {
+                }
+                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) {
@@ -711,7 +1055,7 @@ function requireReact_development() {
                             {
                                 checkKeyStringCoercion(config.key);
                             }
-                            key = "" + config.key;
+                            key = '' + config.key;
                         } // Remaining properties override existing props
                         var defaultProps;
                         if (element.type && element.type.defaultProps) {
@@ -740,17 +1084,19 @@ function requireReact_development() {
                         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 = /**
+                    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+                }
+                var SEPARATOR = '.';
+                var SUBSEPARATOR = ':';
+                /**
 		 * Escape and wrap key so it is safe to use as a reactid
 		 *
 		 * @param {string} key to be escaped.
@@ -758,18 +1104,23 @@ function requireReact_development() {
 		 */ function escape(key) {
                     var escapeRegex = /[=:]/g;
                     var escaperLookup = {
-                        "=": "=0",
-                        ":": "=2"
+                        '=': '=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 = /**
+                    return '$' + escapedString;
+                }
+                /**
+		 * TODO: Test that a single child and an array with one item have the same key
+		 * pattern.
+		 */ var didWarnAboutMaps = false;
+                var userProvidedKeyEscapeRegex = /\/+/g;
+                function escapeUserProvidedKey(text) {
+                    return text.replace(userProvidedKeyEscapeRegex, '$&/');
+                }
+                /**
 		 * Generate a key string that identifies a element within a set.
 		 *
 		 * @param {*} element A element that could contain a manual key.
@@ -778,39 +1129,132 @@ function requireReact_development() {
 		 */ 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) {
+                    if (typeof element === 'object' && element !== null && element.key != null) {
                         // Explicit key
                         {
                             checkKeyStringCoercion(element.key);
                         }
-                        return escape("" + 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;
+                }
+                function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+                    var type = 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;
+                }
+                /**
+		 * 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) {
+                    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`.
 		 *
@@ -824,8 +1268,8 @@ function requireReact_development() {
                         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
@@ -840,8 +1284,8 @@ function requireReact_development() {
                     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.
 		 *
@@ -850,8 +1294,8 @@ function requireReact_development() {
                     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.
 		 *
@@ -866,11 +1310,11 @@ function requireReact_development() {
 		 * structure.
 		 */ function onlyChild(children) {
                     if (!isValidElement(children)) {
-                        throw new Error("React.Children.only expected to receive a single React element child.");
+                        throw new Error('React.Children.only expected to receive a single React element child.');
                     }
                     return children;
-                };
-                var createContext = function createContext(defaultValue) {
+                }
+                function createContext(defaultValue) {
                     // TODO: Second argument used to be an optional `calculateChangedBits`
                     // function. Warn to reserve for future use?
                     var context = {
@@ -909,57 +1353,57 @@ function requireReact_development() {
                         }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
                         Object.defineProperties(Consumer, {
                             Provider: {
-                                get: function get() {
+                                get: function() {
                                     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?");
+                                        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) {
+                                set: function(_Provider) {
                                     context.Provider = _Provider;
                                 }
                             },
                             _currentValue: {
-                                get: function get() {
+                                get: function() {
                                     return context._currentValue;
                                 },
-                                set: function set(_currentValue) {
+                                set: function(_currentValue) {
                                     context._currentValue = _currentValue;
                                 }
                             },
                             _currentValue2: {
-                                get: function get() {
+                                get: function() {
                                     return context._currentValue2;
                                 },
-                                set: function set(_currentValue2) {
+                                set: function(_currentValue2) {
                                     context._currentValue2 = _currentValue2;
                                 }
                             },
                             _threadCount: {
-                                get: function get() {
+                                get: function() {
                                     return context._threadCount;
                                 },
-                                set: function set(_threadCount) {
+                                set: function(_threadCount) {
                                     context._threadCount = _threadCount;
                                 }
                             },
                             Consumer: {
-                                get: function get() {
+                                get: function() {
                                     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?");
+                                        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() {
+                                get: function() {
                                     return context.displayName;
                                 },
-                                set: function set(displayName) {
+                                set: function(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);
+                                        warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName);
                                         hasWarnedAboutDisplayNameOnConsumer = true;
                                     }
                                 }
@@ -972,8 +1416,12 @@ function requireReact_development() {
                         context._currentRenderer2 = null;
                     }
                     return context;
-                };
-                var lazyInitializer = function lazyInitializer(payload) {
+                }
+                var Uninitialized = -1;
+                var Pending = 0;
+                var Resolved = 1;
+                var Rejected = 2;
+                function lazyInitializer(payload) {
                     if (payload._status === Uninitialized) {
                         var ctor = payload._result;
                         var thenable = ctor(); // Transition to the next state.
@@ -1008,22 +1456,22 @@ function requireReact_development() {
                         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);
+                                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);
+                            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) {
+                }
+                function lazy(ctor) {
                     var payload = {
                         // We use these fields to store the result.
                         _status: Uninitialized,
@@ -1041,28 +1489,28 @@ function requireReact_development() {
                         Object.defineProperties(lazyType, {
                             defaultProps: {
                                 configurable: true,
-                                get: function get() {
+                                get: function() {
                                     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.");
+                                set: function(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", {
+                                    Object.defineProperty(lazyType, 'defaultProps', {
                                         enumerable: true
                                     });
                                 }
                             },
                             propTypes: {
                                 configurable: true,
-                                get: function get() {
+                                get: function() {
                                     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.");
+                                set: function(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", {
+                                    Object.defineProperty(lazyType, 'propTypes', {
                                         enumerable: true
                                     });
                                 }
@@ -1070,21 +1518,21 @@ function requireReact_development() {
                         });
                     }
                     return lazyType;
-                };
-                var forwardRef = function forwardRef(render) {
+                }
+                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));
+                            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);
                         } 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.");
+                                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?");
+                                error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?');
                             }
                         }
                     }
@@ -1094,13 +1542,13 @@ function requireReact_development() {
                     };
                     {
                         var ownName;
-                        Object.defineProperty(elementType, "displayName", {
+                        Object.defineProperty(elementType, 'displayName', {
                             enumerable: false,
                             configurable: true,
-                            get: function get() {
+                            get: function() {
                                 return ownName;
                             },
-                            set: function set(name) {
+                            set: function(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,
@@ -1115,15 +1563,19 @@ function requireReact_development() {
                         });
                     }
                     return elementType;
-                };
-                var isValidElementType = function isValidElementType(type) {
-                    if (typeof type === "string" || typeof type === "function") {
+                }
+                var REACT_MODULE_REFERENCE;
+                {
+                    REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+                }
+                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 (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
@@ -1133,11 +1585,11 @@ function requireReact_development() {
                         }
                     }
                     return false;
-                };
-                var memo = function memo(type, compare) {
+                }
+                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));
+                            error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
                         }
                     }
                     var elementType = {
@@ -1147,13 +1599,13 @@ function requireReact_development() {
                     };
                     {
                         var ownName;
-                        Object.defineProperty(elementType, "displayName", {
+                        Object.defineProperty(elementType, 'displayName', {
                             enumerable: false,
                             configurable: true,
-                            get: function get() {
+                            get: function() {
                                 return ownName;
                             },
-                            set: function set(name) {
+                            set: function(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,
@@ -1168,19 +1620,19 @@ function requireReact_development() {
                         });
                     }
                     return elementType;
-                };
-                var resolveDispatcher = function 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.");
+                            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) {
+                }
+                function useContext(Context) {
                     var dispatcher = resolveDispatcher();
                     {
                         // TODO: add a more generic warning for invalid values.
@@ -1188,74 +1640,87 @@ function requireReact_development() {
                             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?");
+                                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?");
+                                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) {
+                }
+                function useState(initialState) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useState(initialState);
-                };
-                var useReducer = function useReducer(reducer, initialArg, init) {
+                }
+                function useReducer(reducer, initialArg, init) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useReducer(reducer, initialArg, init);
-                };
-                var useRef = function useRef(initialValue) {
+                }
+                function useRef(initialValue) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useRef(initialValue);
-                };
-                var useEffect = function useEffect(create, deps) {
+                }
+                function useEffect(create, deps) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useEffect(create, deps);
-                };
-                var useInsertionEffect = function useInsertionEffect(create, deps) {
+                }
+                function useInsertionEffect(create, deps) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useInsertionEffect(create, deps);
-                };
-                var useLayoutEffect = function useLayoutEffect(create, deps) {
+                }
+                function useLayoutEffect(create, deps) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useLayoutEffect(create, deps);
-                };
-                var useCallback = function useCallback(callback, deps) {
+                }
+                function useCallback(callback, deps) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useCallback(callback, deps);
-                };
-                var useMemo = function useMemo(create, deps) {
+                }
+                function useMemo(create, deps) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useMemo(create, deps);
-                };
-                var useImperativeHandle = function useImperativeHandle(ref, create, deps) {
+                }
+                function useImperativeHandle(ref, create, deps) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useImperativeHandle(ref, create, deps);
-                };
-                var useDebugValue = function useDebugValue(value, formatterFn) {
+                }
+                function useDebugValue(value, formatterFn) {
                     {
                         var dispatcher = resolveDispatcher();
                         return dispatcher.useDebugValue(value, formatterFn);
                     }
-                };
-                var useTransition = function useTransition() {
+                }
+                function useTransition() {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useTransition();
-                };
-                var useDeferredValue = function useDeferredValue(value) {
+                }
+                function useDeferredValue(value) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useDeferredValue(value);
-                };
-                var useId = function useId() {
+                }
+                function useId() {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useId();
-                };
-                var useSyncExternalStore = function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+                }
+                function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
                     var dispatcher = resolveDispatcher();
                     return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-                };
-                var disabledLog = function disabledLog() {};
-                var disableLogs = function disableLogs() {
+                }
+                // 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;
+                function disabledLog() {}
+                disabledLog.__reactDisabledLog = true;
+                function disableLogs() {
                     {
                         if (disabledDepth === 0) {
                             /* eslint-disable react-internal/no-production-logging */ prevLog = console.log;
@@ -1283,8 +1748,8 @@ function requireReact_development() {
                         /* eslint-enable react-internal/no-production-logging */ }
                         disabledDepth++;
                     }
-                };
-                var reenableLogs = function reenableLogs() {
+                }
+                function reenableLogs() {
                     {
                         disabledDepth--;
                         if (disabledDepth === 0) {
@@ -1318,11 +1783,13 @@ function requireReact_development() {
                             });
                         /* 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.");
+                            error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
                         }
                     }
-                };
-                var describeBuiltInComponentFrame = function describeBuiltInComponentFrame(name, source, ownerFn) {
+                }
+                var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+                var prefix;
+                function describeBuiltInComponentFrame(name, source, ownerFn) {
                     {
                         if (prefix === undefined) {
                             // Extract the VM specific prefix used by each line.
@@ -1330,16 +1797,22 @@ function requireReact_development() {
                                 throw Error();
                             } catch (x) {
                                 var match = x.stack.trim().match(/\n( *(at )?)/);
-                                prefix = match && match[1] || "";
+                                prefix = match && match[1] || '';
                             }
                         } // We use the prefix to ensure our stacks line up with native stack frames.
-                        return "\n" + prefix + name;
+                        return '\n' + prefix + name;
                     }
-                };
-                var describeNativeComponentFrame = function describeNativeComponentFrame(fn, construct) {
+                }
+                var reentry = false;
+                var componentFrameCache;
+                {
+                    var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+                    componentFrameCache = new PossiblyWeakMap();
+                }
+                function describeNativeComponentFrame(fn, construct) {
                     // If something asked for a stack inside a fake render, it should get ignored.
                     if (!fn || reentry) {
-                        return "";
+                        return '';
                     }
                     {
                         var frame = componentFrameCache.get(fn);
@@ -1362,17 +1835,17 @@ function requireReact_development() {
                         // This should throw.
                         if (construct) {
                             // Something should be setting the props in the constructor.
-                            var Fake = function Fake() {
+                            var Fake = function() {
                                 throw Error();
                             }; // $FlowFixMe
-                            Object.defineProperty(Fake.prototype, "props", {
-                                set: function set() {
+                            Object.defineProperty(Fake.prototype, 'props', {
+                                set: function() {
                                     // 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) {
+                            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 {
@@ -1384,26 +1857,26 @@ function requireReact_development() {
                             } else {
                                 try {
                                     Fake.call();
-                                } catch (x1) {
-                                    control = x1;
+                                } catch (x) {
+                                    control = x;
                                 }
                                 fn.call(Fake.prototype);
                             }
                         } else {
                             try {
                                 throw Error();
-                            } catch (x2) {
-                                control = x2;
+                            } catch (x) {
+                                control = x;
                             }
                             fn();
                         }
                     } catch (sample) {
                         // This is inlined manually because closure doesn't do it for us.
-                        if (sample && control && typeof sample.stack === "string") {
+                        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 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]){
@@ -1431,20 +1904,20 @@ function requireReact_development() {
                                             // 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>"
+                                                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 (fn.displayName && _frame.includes('<anonymous>')) {
+                                                    _frame = _frame.replace('<anonymous>', fn.displayName);
                                                 }
                                                 {
-                                                    if (typeof fn === "function") {
+                                                    if (typeof fn === 'function') {
                                                         componentFrameCache.set(fn, _frame);
                                                     }
                                                 }
                                                 return _frame;
                                             }
-                                        }while (s >= 1 && c >= 0);
+                                        }while (s >= 1 && c >= 0)
                                     }
                                     break;
                                 }
@@ -1458,25 +1931,66 @@ function requireReact_development() {
                         }
                         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) : "";
+                    var name = fn ? fn.displayName || fn.name : '';
+                    var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
                     {
-                        if (typeof fn === "function") {
+                        if (typeof fn === 'function') {
                             componentFrameCache.set(fn, syntheticFrame);
                         }
                     }
                     return syntheticFrame;
-                };
-                var describeFunctionComponentFrame = function describeFunctionComponentFrame(fn, source, ownerFn) {
+                }
+                function describeFunctionComponentFrame(fn, source, ownerFn) {
                     {
                         return describeNativeComponentFrame(fn, false);
                     }
-                };
-                var shouldConstruct = function shouldConstruct(Component) {
+                }
+                function shouldConstruct(Component) {
                     var prototype = Component.prototype;
                     return !!(prototype && prototype.isReactComponent);
-                };
-                var setCurrentlyValidatingElement = function setCurrentlyValidatingElement(element) {
+                }
+                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;
+                function setCurrentlyValidatingElement(element) {
                     {
                         if (element) {
                             var owner = element._owner;
@@ -1486,8 +2000,8 @@ function requireReact_development() {
                             ReactDebugCurrentFrame$1.setExtraStackFrame(null);
                         }
                     }
-                };
-                var checkPropTypes = function checkPropTypes(typeSpecs, values, location, componentName, element) {
+                }
+                function checkPropTypes(typeSpecs, values, location, componentName, element) {
                     {
                         // $FlowFixMe This is okay but Flow doesn't know it.
                         var has = Function.call.bind(hasOwnProperty);
@@ -1499,34 +2013,34 @@ function requireReact_development() {
                                 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") {
+                                    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";
+                                        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");
+                                    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)) {
+                                if (error$1 && !(error$1 instanceof 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));
+                                    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);
                                     setCurrentlyValidatingElement(null);
                                 }
-                                if (_instanceof(error$1, Error) && !(error$1.message in loggedTypeFailures)) {
+                                if (error$1 instanceof 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);
+                                    error('Failed %s type: %s', location, error$1.message);
                                     setCurrentlyValidatingElement(null);
                                 }
                             }
                         }
                     }
-                };
-                var setCurrentlyValidatingElement$1 = function setCurrentlyValidatingElement$1(element) {
+                }
+                function setCurrentlyValidatingElement$1(element) {
                     {
                         if (element) {
                             var owner = element._owner;
@@ -1536,41 +2050,50 @@ function requireReact_development() {
                             setExtraStackFrame(null);
                         }
                     }
-                };
-                var getDeclarationErrorAddendum = function getDeclarationErrorAddendum() {
+                }
+                var propTypesMisspellWarningShown;
+                {
+                    propTypesMisspellWarningShown = false;
+                }
+                function getDeclarationErrorAddendum() {
                     if (ReactCurrentOwner.current) {
                         var name = getComponentNameFromType(ReactCurrentOwner.current.type);
                         if (name) {
-                            return "\n\nCheck the render method of `" + name + "`.";
+                            return '\n\nCheck the render method of `' + name + '`.';
                         }
                     }
-                    return "";
-                };
-                var getSourceInfoErrorAddendum = function getSourceInfoErrorAddendum(source) {
+                    return '';
+                }
+                function getSourceInfoErrorAddendum(source) {
                     if (source !== undefined) {
-                        var fileName = source.fileName.replace(/^.*[\\\/]/, "");
+                        var fileName = source.fileName.replace(/^.*[\\\/]/, '');
                         var lineNumber = source.lineNumber;
-                        return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
+                        return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
                     }
-                    return "";
-                };
-                var getSourceInfoErrorAddendumForProps = function getSourceInfoErrorAddendumForProps(elementProps) {
+                    return '';
+                }
+                function getSourceInfoErrorAddendumForProps(elementProps) {
                     if (elementProps !== null && elementProps !== undefined) {
                         return getSourceInfoErrorAddendum(elementProps.__source);
                     }
-                    return "";
-                };
-                var getCurrentComponentErrorInfo = function getCurrentComponentErrorInfo(parentType) {
+                    return '';
+                }
+                /**
+		 * 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 = {};
+                function getCurrentComponentErrorInfo(parentType) {
                     var info = getDeclarationErrorAddendum();
                     if (!info) {
-                        var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
+                        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
@@ -1592,18 +2115,18 @@ function requireReact_development() {
                     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 = "";
+                    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);
+                        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.
@@ -1612,7 +2135,7 @@ function requireReact_development() {
 		 * @param {ReactNode} node Statically passed child of any type.
 		 * @param {*} parentType node's parent's type.
 		 */ function validateChildKeys(node, parentType) {
-                    if (typeof node !== "object") {
+                    if (typeof node !== 'object') {
                         return;
                     }
                     if (isArray(node)) {
@@ -1629,7 +2152,7 @@ function requireReact_development() {
                         }
                     } else if (node) {
                         var iteratorFn = getIteratorFn(node);
-                        if (typeof iteratorFn === "function") {
+                        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) {
@@ -1643,8 +2166,8 @@ function requireReact_development() {
                             }
                         }
                     }
-                };
-                var validatePropTypes = /**
+                }
+                /**
 		 * Given an element, validate that its props follow the propTypes definition,
 		 * provided by the type.
 		 *
@@ -1652,13 +2175,13 @@ function requireReact_development() {
 		 */ function validatePropTypes(element) {
                     {
                         var type = element.type;
-                        if (type === null || type === undefined || typeof type === "string") {
+                        if (type === null || type === undefined || typeof type === 'string') {
                             return;
                         }
                         var propTypes;
-                        if (typeof type === "function") {
+                        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.
+                        } 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;
@@ -1668,46 +2191,46 @@ function requireReact_development() {
                         if (propTypes) {
                             // Intentionally inside to avoid triggering lazy initializers:
                             var name = getComponentNameFromType(type);
-                            checkPropTypes(propTypes, element.props, "prop", name, element);
+                            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");
+                            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.");
+                        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
+                }
+                /**
+		 * 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") {
+                            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);
+                                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`.");
+                            error('Invalid attribute `ref` supplied to `React.Fragment`.');
                             setCurrentlyValidatingElement$1(null);
                         }
                     }
-                };
-                var createElementWithValidation = function createElementWithValidation(type, props, children) {
+                }
+                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 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) {
@@ -1717,17 +2240,17 @@ function requireReact_development() {
                         }
                         var typeString;
                         if (type === null) {
-                            typeString = "null";
+                            typeString = 'null';
                         } else if (isArray(type)) {
-                            typeString = "array";
+                            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?";
+                            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);
+                            typeString = 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);
+                            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.
@@ -1750,20 +2273,21 @@ function requireReact_development() {
                         validatePropTypes(element);
                     }
                     return element;
-                };
-                var createFactoryWithValidation = function createFactoryWithValidation(type) {
+                }
+                var didWarnAboutDeprecatedCreateFactory = false;
+                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.");
+                            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", {
+                        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", {
+                            get: function() {
+                                warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+                                Object.defineProperty(this, 'type', {
                                     value: type
                                 });
                                 return type;
@@ -1771,16 +2295,16 @@ function requireReact_development() {
                         });
                     }
                     return validatedFactory;
-                };
-                var cloneElementWithValidation = function cloneElementWithValidation(element, props, children) {
+                }
+                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) {
+                }
+                function startTransition(scope, options) {
                     var prevTransition = ReactCurrentBatchConfig.transition;
                     ReactCurrentBatchConfig.transition = {};
                     var currentTransition = ReactCurrentBatchConfig.transition;
@@ -1795,32 +2319,34 @@ function requireReact_development() {
                             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.");
+                                    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) {
+                }
+                var didWarnAboutMessageChannel = false;
+                var enqueueTaskImpl = null;
+                function enqueueTask(task) {
                     if (enqueueTaskImpl === null) {
                         try {
                             // read require off the module object to get around the bundlers.
                             // we don't want them to detect a require and bundle a Node polyfill.
-                            var requireString = ("require" + Math.random()).slice(0, 7);
+                            var 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;
+                            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) {
+                            enqueueTaskImpl = function(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.");
+                                        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.');
                                         }
                                     }
                                 }
@@ -1831,8 +2357,10 @@ function requireReact_development() {
                         }
                     }
                     return enqueueTaskImpl(task);
-                };
-                var act = function act(callback) {
+                }
+                var actScopeDepth = 0;
+                var didWarnNoAwaitAct = false;
+                function act(callback) {
                     {
                         // `act` calls can be nested, so we track the depth. This represents the
                         // number of `act` scopes on the stack.
@@ -1861,18 +2389,18 @@ function requireReact_development() {
                                     flushActQueue(queue);
                                 }
                             }
-                        } catch (error1) {
+                        } catch (error) {
                             popActScope(prevActScopeDepth);
-                            throw error1;
+                            throw error;
                         } finally{
                             ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
                         }
-                        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+                        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) {
+                                then: function(resolve, reject) {
                                     wasAwaited = true;
                                     thenableResult.then(function(returnValue) {
                                         popActScope(prevActScopeDepth);
@@ -1891,12 +2419,12 @@ function requireReact_development() {
                                 }
                             };
                             {
-                                if (!didWarnNoAwaitAct && typeof Promise !== "undefined") {
+                                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 () => ...);");
+                                            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 () => ...);');
                                         }
                                     });
                                 }
@@ -1915,7 +2443,7 @@ function requireReact_development() {
                                 } // 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) {
+                                    then: function(resolve, reject) {
                                         // Confirm we haven't re-entered another `act` scope, in case
                                         // the user does something weird like await the thenable
                                         // multiple times.
@@ -1933,7 +2461,7 @@ function requireReact_development() {
                                 // 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) {
+                                    then: function(resolve, reject) {
                                         resolve(returnValue);
                                     }
                                 };
@@ -1941,16 +2469,41 @@ function requireReact_development() {
                             }
                         }
                     }
-                };
-                var popActScope = function popActScope(prevActScopeDepth) {
+                }
+                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. ");
+                            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) {
+                }
+                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;
+                function flushActQueue(queue) {
                     {
                         if (!isFlushing) {
                             // Prevent re-entrance.
@@ -1961,7 +2514,7 @@ function requireReact_development() {
                                     var callback = queue[i];
                                     do {
                                         callback = callback(true);
-                                    }while (callback !== null);
+                                    }while (callback !== null)
                                 }
                                 queue.length = 0;
                             } catch (error) {
@@ -1973,640 +2526,54 @@ function requireReact_development() {
                             }
                         }
                     }
-                };
-                /* 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 createElement$1 = createElementWithValidation;
+                var cloneElement$1 = cloneElementWithValidation;
+                var createFactory = createFactoryWithValidation;
+                var Children = {
+                    map: mapChildren,
+                    forEach: forEachChildren,
+                    count: countChildren,
+                    toArray: toArray,
+                    only: onlyChild
                 };
-                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());
+                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());
                 }
             })();
         }
@@ -2614,350 +2581,218 @@ function requireReact_development() {
     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);
+if (process.env.NODE_ENV === 'production') {
+    react.exports = requireReact_production_min();
+} else {
+    react.exports = requireReact_development();
 }
+var reactExports = react.exports;
+var React = /*@__PURE__*/ getDefaultExportFromCjs(reactExports);
 
-// @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));
-}
+const SIZE = 16;
+const BASE_RADIUS = SIZE / 3;
+const BASE_FONT_SIZE = SIZE;
 
-// @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];
+function layoutPropsToStyles({ padding }) {
+    let newStyles = {};
+    if (padding) {
+        newStyles.padding = `${SIZE * padding}px`;
     }
-    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)
-    };
+    return newStyles;
 }
+
 function classList(classes) {
     if (Array.isArray(classes)) {
-        return classes.filter(function(e) {
-            return e;
-        }).join(" ");
+        return classes.filter((e)=>e).join(' ');
     } else {
-        return Object.keys(classes).filter(function(e) {
-            return classes[e];
-        }).join(" ");
+        return Object.keys(classes).filter((e)=>classes[e]).join(' ');
     }
 }
-function layoutPropsToStyles(param) {
-    var padding = param.padding;
-    var newStyles = {};
-    if (padding) {
-        newStyles.padding = "" + getSettings().size * padding + "px";
-    }
-    return newStyles;
+
+function Box({ children, smallText, padding, flex, style }) {
+    const styles = {
+        flex,
+        ...layoutPropsToStyles({
+            padding
+        }),
+        ...style
+    };
+    const className = classList({
+        'jb-box': true,
+        'jbx-small-text': smallText
+    });
+    return /*#__PURE__*/ React.createElement("div", {
+        className: className,
+        style: styles
+    }, children);
 }
-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);
+
+function Component(className, styleSrc = {}, config = {}) {
+    const { element = `div`, props: otherProps } = config;
+    return function MakeComponent({ children, style = {}, ...props }) {
+        const calculatedStyle = typeof styleSrc === 'function' ? styleSrc(props) : styleSrc;
+        return /*#__PURE__*/ reactExports.createElement(element, {
+            className,
+            style: {
+                ...style,
+                ...calculatedStyle
+            },
+            ...otherProps,
+            ...props
+        }, 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"
+const Container = Component(`jbx-container`);
+const Text = Component(`jbx-text`);
+const SmallText = Component(`jbx-small-text`);
+const Button = Component(`jbx-button`, {}, {
+    element: 'button'
 });
-var Range = Component("jbx-range", null, {
-    element: "input"
+const Input = Component(`jbx-input`, {}, {
+    element: 'input'
 });
-var HeaderH1 = Component("jbx-h" + 1, null, {
-    element: "h1"
+const Range = Component(`jbx-range`, {}, {
+    element: 'input',
+    props: {
+        type: 'range'
+    }
 });
-var HeaderH2 = Component("jbx-h" + 2, null, {
-    element: "h2"
+const HeaderH1 = Component(`jbx-h${1}`, {}, {
+    element: 'h1'
 });
-var HeaderH3 = Component("jbx-h" + 3, null, {
-    element: "h3"
+const HeaderH2 = Component(`jbx-h${2}`, {}, {
+    element: 'h2'
 });
-var HeaderH4 = Component("jbx-h" + 4, null, {
-    element: "h4"
+const HeaderH3 = Component(`jbx-h${3}`, {}, {
+    element: 'h3'
 });
-var HR = Component("jbx-hr", null, {
-    element: "hr"
+const HeaderH4 = Component(`jbx-h${4}`, {}, {
+    element: 'h4'
 });
-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"
+const HR = Component(`jbx-hr`, {}, {
+    element: 'hr'
 });
-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"
-    };
+const MainHeader = Component(`jbx-main-h1`, {}, {
+    element: 'h1'
 });
-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"
-    };
+const A = Component(`jbx-a`, {}, {
+    element: 'a'
 });
-var Dropzone = Component("jbx-dropzone");
-var Ul = Component("jbx-ul", {
+const Space = Component(`jbx-space`, ({ inline, h, w })=>({
+        display: inline ? 'inline-block' : 'block',
+        height: h ? `${SIZE * h}px` : undefined,
+        width: w ? `${SIZE * w}px` : undefined
+    }));
+const Inline = Component(`jbx-inline`, ({ v, h, gap, wrap = false })=>({
+        marginLeft: h ? `${h * SIZE}px` : undefined,
+        marginRight: h ? `${h * SIZE}px` : undefined,
+        marginTop: v ? `${v * SIZE}px` : undefined,
+        marginBottom: v ? `${v * SIZE}px` : undefined,
+        gap: gap ? `${gap * SIZE}px` : undefined,
+        flexWrap: wrap ? 'wrap' : 'no-wrap'
+    }));
+const Stack = Component(`jbx-stack`, ({ v, h, gap })=>({
+        marginLeft: h ? `${h * SIZE}px` : undefined,
+        marginRight: h ? `${h * SIZE}px` : undefined,
+        marginTop: v ? `${v * SIZE}px` : undefined,
+        marginBottom: v ? `${v * SIZE}px` : undefined,
+        gap: gap ? `${gap * SIZE}px` : undefined
+    }));
+const Dropzone = Component(`jbx-dropzone`);
+const Ul = Component(`jbx-ul`, {
     margin: 0,
-    padding: "0 0 0 " + BASE_FONT_SIZE / 4 + "px"
+    padding: `0 0 0 ${BASE_FONT_SIZE / 4}px`
 }, {
-    element: "ul"
+    element: 'ul'
 });
-var Li = Component("jbx-li", {
-    margin: "0 0 0 " + SIZE + "px",
-    padding: "" + SIZE / 4 + "px 0"
+const Li = Component(`jbx-li`, {
+    margin: `0 0 0 ${SIZE}px`,
+    padding: `${SIZE / 4}px 0`
 }, {
-    element: "li"
+    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",
+const Tabs = Component(`jbx-tabs`);
+const Tab = Component(`jbx-tabs--tab`, ({ info, active })=>({
+        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"
+    }));
+const CodeSnippet = Component(`jbx-code-snippet`, {}, {
+    element: 'pre'
 });
-var CodeTextarea = Component("jbx-code-area", null, {
-    element: "textarea"
+const CodeTextarea = Component(`jbx-code-area`, {}, {
+    element: 'textarea'
 });
-var CheckboxHidden = Component("jbx-checkbox-hidden", function(param) {
-    var checked = param.checked;
+const CheckboxHidden = Component(`jbx-checkbox-hidden`, ({ checked })=>{
     return {
         height: SIZE * 2 - 4,
         width: SIZE * 2 - 4,
         paddingTop: 2,
         paddingLeft: 2,
-        backgroundColor: checked ? "var(--accent-color)" : "white",
+        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"
+        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;
+// export const Checkbox = function Checkbox({
+//   label,
+//   checked,
+//   onChange
+// }: {
+//   label: string;
+//   checked: boolean;
+//   onChange?: (value: boolean) => void;
+// }) {
+//   return React.createElement(
+//     Inline,
+//     {
+//       onClick: () => {
+//         if (onChange) {
+//           onChange(!checked);
+//         }
+//       },
+//       style: {
+//         alignItems: 'center',
+//         cursor: 'pointer'
+//       }
+//     },
+//     [
+//       React.createElement(
+//         CheckboxHidden,
+//         {
+//           key: 0,
+//           checked
+//         },
+//         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'
+//           },
+//           React.createElement('path', {
+//             d: 'M20 6L9 17 4 12'
+//           })
+//         )
+//       ),
+//       React.createElement(Space, { key: 1, w: 0.5 }),
+//       React.createElement(Text, { key: 2, style: { userSelect: 'none' } }, label)
+//     ]
+//   );
+// };
+function Bullet({ value }) {
     return /*#__PURE__*/ React.createElement("div", {
         className: "jbx-bullet-container"
     }, /*#__PURE__*/ React.createElement("div", {
@@ -2965,4 +2800,4 @@ function Bullet(param) {
     }, value));
 }
 
-export { A, Box, Bullet, Button, Checkbox, CheckboxHidden, CodeSnippet, CodeTextarea, Component, Container, Dropzone, HR, HeaderH1, HeaderH2, HeaderH3, HeaderH4, Inline, Input, Li, MainHeader, MoreExperiments, Range, SmallText, Space, Stack, Tab, Tabs, Text, Ul, classList, getSettings, layoutPropsToStyles };
+export { A, Box, Bullet, Button, CheckboxHidden, CodeSnippet, CodeTextarea, Component, Container, Dropzone, HR, HeaderH1, HeaderH2, HeaderH3, HeaderH4, Inline, Input, Li, MainHeader, Range, SmallText, Space, Stack, Tab, Tabs, Text, Ul };