@realsee/live 0.4.0-alpha.2 → 0.4.0-alpha.3

package/dist/realsee-live.umd.development.js

@@ -10658,7 +10658,7 @@
            : part2 < 128 ? 9 : 10;
   };
 
-  var require$$0$5 = aspromise;
+  var require$$0$6 = aspromise;
 
   var require$$1$3 = base64_1;
 
@@ -10678,7 +10678,7 @@
   var util = exports;
 
   // used to return a Promise where callback is omitted
-  util.asPromise = require$$0$5;
+  util.asPromise = require$$0$6;
 
   // converts to / from base64 encoded strings
   util.base64 = require$$1$3;
@@ -11549,13 +11549,13 @@
       BufferWriter$1 = BufferWriter_;
   };
 
-  var require$$0$4 = writer;
+  var require$$0$5 = writer;
 
   var writer_buffer = BufferWriter;
 
   // extends Writer
 
-  (BufferWriter.prototype = Object.create(require$$0$4.prototype)).constructor = BufferWriter;
+  (BufferWriter.prototype = Object.create(require$$0$5.prototype)).constructor = BufferWriter;
 
 
 
@@ -11568,7 +11568,7 @@
    * @constructor
    */
   function BufferWriter() {
-      require$$0$4.call(this);
+      require$$0$5.call(this);
   }
 
   /**
@@ -12210,7 +12210,7 @@
       return this;
   };
 
-  var require$$0$3 = service;
+  var require$$0$4 = service;
 
   var rpc_1 = createCommonjsModule(function (module, exports) {
 
@@ -12247,7 +12247,7 @@
    * @returns {undefined}
    */
 
-  rpc.Service = require$$0$3;
+  rpc.Service = require$$0$4;
   });
 
   var roots = {};
@@ -12272,7 +12272,7 @@
   protobuf.build = "minimal";
 
   // Serialization
-  protobuf.Writer       = require$$0$4;
+  protobuf.Writer       = require$$0$5;
   protobuf.BufferWriter = require$$1$2;
   protobuf.Reader       = require$$2;
   protobuf.BufferReader = require$$3;
@@ -12298,9 +12298,9 @@
   configure();
   });
 
-  var require$$0$2 = indexMinimal;
+  var require$$0$3 = indexMinimal;
 
-  var minimal = require$$0$2;
+  var minimal = require$$0$3;
 
   var $protobuf = minimal;
 
@@ -31104,7 +31104,7 @@
     //Z_NULL:                 null // Use -1 or null inline, depending on var type
   };
 
-  var require$$0$1 = trees;
+  var require$$0$2 = trees;
 
   var adler32 = adler32_1;
 
@@ -31133,7 +31133,7 @@
   //   misrepresented as being the original software.
   // 3. This notice may not be removed or altered from any source distribution.
 
-  const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = require$$0$1;
+  const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = require$$0$2;
 
 
 
@@ -36365,11 +36365,11 @@
   	constants: constants
   };
 
-  var require$$0 = deflate_1$1;
+  var require$$0$1 = deflate_1$1;
 
   var require$$1$1 = inflate_1$1;
 
-  const { Deflate, deflate, deflateRaw, gzip } = require$$0;
+  const { Deflate, deflate, deflateRaw, gzip } = require$$0$1;
 
   const { Inflate, inflate, inflateRaw, ungzip } = require$$1$1;
 
@@ -49474,8 +49474,98 @@
       return live;
   }
 
-  /**
-   * @license React
+  /*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  */
+  /* eslint-disable no-unused-vars */
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+  function toObject(val) {
+  	if (val === null || val === undefined) {
+  		throw new TypeError('Object.assign cannot be called with null or undefined');
+  	}
+
+  	return Object(val);
+  }
+
+  function shouldUseNative() {
+  	try {
+  		if (!Object.assign) {
+  			return false;
+  		}
+
+  		// Detect buggy property enumeration order in older V8 versions.
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+  		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+  		test1[5] = 'de';
+  		if (Object.getOwnPropertyNames(test1)[0] === '5') {
+  			return false;
+  		}
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+  		var test2 = {};
+  		for (var i = 0; i < 10; i++) {
+  			test2['_' + String.fromCharCode(i)] = i;
+  		}
+  		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+  			return test2[n];
+  		});
+  		if (order2.join('') !== '0123456789') {
+  			return false;
+  		}
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+  		var test3 = {};
+  		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+  			test3[letter] = letter;
+  		});
+  		if (Object.keys(Object.assign({}, test3)).join('') !==
+  				'abcdefghijklmnopqrst') {
+  			return false;
+  		}
+
+  		return true;
+  	} catch (err) {
+  		// We don't expect any of the above to throw, but better to be safe.
+  		return false;
+  	}
+  }
+
+  var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+  	var from;
+  	var to = toObject(target);
+  	var symbols;
+
+  	for (var s = 1; s < arguments.length; s++) {
+  		from = Object(arguments[s]);
+
+  		for (var key in from) {
+  			if (hasOwnProperty.call(from, key)) {
+  				to[key] = from[key];
+  			}
+  		}
+
+  		if (getOwnPropertySymbols) {
+  			symbols = getOwnPropertySymbols(from);
+  			for (var i = 0; i < symbols.length; i++) {
+  				if (propIsEnumerable.call(from, symbols[i])) {
+  					to[symbols[i]] = from[symbols[i]];
+  				}
+  			}
+  		}
+  	}
+
+  	return to;
+  };
+
+  var require$$0 = objectAssign;
+
+  /** @license React v17.0.2
    * react.development.js
    *
    * Copyright (c) Facebook, Inc. and its affiliates.
@@ -49489,44 +49579,59 @@
   {
     (function() {
 
-  /* 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.1.0';
-
-  // -----------------------------------------------------------------------------
-
-  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 _assign = require$$0;
 
-  var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+  // TODO: this is special because it gets imported during build.
+  var ReactVersion = '17.0.2';
 
   // ATTENTION
-
-  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;
+  // 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. If there is no native Symbol
+  // nor polyfill, then a plain number is used for performance.
+  var REACT_ELEMENT_TYPE = 0xeac7;
+  var REACT_PORTAL_TYPE = 0xeaca;
+  exports.Fragment = 0xeacb;
+  exports.StrictMode = 0xeacc;
+  exports.Profiler = 0xead2;
+  var REACT_PROVIDER_TYPE = 0xeacd;
+  var REACT_CONTEXT_TYPE = 0xeace;
+  var REACT_FORWARD_REF_TYPE = 0xead0;
+  exports.Suspense = 0xead1;
+  var REACT_SUSPENSE_LIST_TYPE = 0xead8;
+  var REACT_MEMO_TYPE = 0xead3;
+  var REACT_LAZY_TYPE = 0xead4;
+  var REACT_BLOCK_TYPE = 0xead9;
+  var REACT_SERVER_BLOCK_TYPE = 0xeada;
+  var REACT_FUNDAMENTAL_TYPE = 0xead5;
+  var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
+  var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
+
+  if (typeof Symbol === 'function' && Symbol.for) {
+    var symbolFor = Symbol.for;
+    REACT_ELEMENT_TYPE = symbolFor('react.element');
+    REACT_PORTAL_TYPE = symbolFor('react.portal');
+    exports.Fragment = symbolFor('react.fragment');
+    exports.StrictMode = symbolFor('react.strict_mode');
+    exports.Profiler = symbolFor('react.profiler');
+    REACT_PROVIDER_TYPE = symbolFor('react.provider');
+    REACT_CONTEXT_TYPE = symbolFor('react.context');
+    REACT_FORWARD_REF_TYPE = symbolFor('react.forward_ref');
+    exports.Suspense = symbolFor('react.suspense');
+    REACT_SUSPENSE_LIST_TYPE = symbolFor('react.suspense_list');
+    REACT_MEMO_TYPE = symbolFor('react.memo');
+    REACT_LAZY_TYPE = symbolFor('react.lazy');
+    REACT_BLOCK_TYPE = symbolFor('react.block');
+    REACT_SERVER_BLOCK_TYPE = symbolFor('react.server.block');
+    REACT_FUNDAMENTAL_TYPE = symbolFor('react.fundamental');
+    symbolFor('react.scope');
+    symbolFor('react.opaque.id');
+    REACT_DEBUG_TRACING_MODE_TYPE = symbolFor('react.debug_trace_mode');
+    symbolFor('react.offscreen');
+    REACT_LEGACY_HIDDEN_TYPE = symbolFor('react.legacy_hidden');
+  }
+
+  var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
   var FAUX_ITERATOR_SYMBOL = '@@iterator';
   function getIteratorFn(maybeIterable) {
     if (maybeIterable === null || typeof maybeIterable !== 'object') {
@@ -49558,14 +49663,7 @@
    * 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
+    transition: 0
   };
 
   /**
@@ -49618,15 +49716,24 @@
     };
   }
 
+  /**
+   * Used by act() to track whether you're inside an act() scope.
+   */
+  var IsSomeRendererActing = {
+    current: false
+  };
+
   var ReactSharedInternals = {
     ReactCurrentDispatcher: ReactCurrentDispatcher,
     ReactCurrentBatchConfig: ReactCurrentBatchConfig,
-    ReactCurrentOwner: ReactCurrentOwner
+    ReactCurrentOwner: ReactCurrentOwner,
+    IsSomeRendererActing: IsSomeRendererActing,
+    // Used by renderers to avoid bundling object-assign twice in UMD bundles:
+    assign: _assign
   };
 
   {
     ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
-    ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
   }
 
   // by calls to these methods by a Babel plugin.
@@ -49636,24 +49743,20 @@
 
   function warn(format) {
     {
-      {
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        printWarning('warn', format, args);
+      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);
     }
   }
   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);
+      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);
     }
   }
 
@@ -49667,11 +49770,10 @@
       if (stack !== '') {
         format += '%s';
         args = args.concat([stack]);
-      } // eslint-disable-next-line react-internal/safe-string-coercion
-
+      }
 
       var argsWithFormat = args.map(function (item) {
-        return String(item);
+        return '' + item;
       }); // Careful: RN currently depends on this prefix
 
       argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
@@ -49769,8 +49871,6 @@
     }
   };
 
-  var assign = Object.assign;
-
   var emptyObject = {};
 
   {
@@ -49819,8 +49919,10 @@
    */
 
   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.');
+    if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {
+      {
+        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, partialState, callback, 'setState');
@@ -49892,7 +49994,8 @@
   var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
   pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
 
-  assign(pureComponentPrototype, Component.prototype);
+  _assign(pureComponentPrototype, Component.prototype);
+
   pureComponentPrototype.isPureReactComponent = true;
 
   // an immutable object with a single mutable value
@@ -49908,96 +50011,16 @@
     return refObject;
   }
 
-  var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
-
-  function isArray(a) {
-    return isArrayImpl(a);
-  }
-
-  /*
-   * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
-   * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
-   *
-   * The functions in this module will throw an easier-to-understand,
-   * easier-to-debug exception with a clear errors message message explaining the
-   * problem. (Instead of a confusing exception thrown inside the implementation
-   * of the `value` object).
-   */
-  // $FlowFixMe only called in DEV, so void return is not possible.
-  function typeName(value) {
-    {
-      // toStringTag is needed for namespaced types like Temporal.Instant
-      var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
-      var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
-      return type;
-    }
-  } // $FlowFixMe only called in DEV, so void return is not possible.
-
-
-  function willCoercionThrow(value) {
-    {
-      try {
-        return false;
-      } catch (e) {
-        return true;
-      }
-    }
-  }
-
-  function testStringCoercion(value) {
-    // If you ended up here by following an exception call stack, here's what's
-    // happened: you supplied an object or symbol value to React (as a prop, key,
-    // DOM attribute, CSS property, string ref, etc.) and when React tried to
-    // coerce it to a string using `'' + value`, an exception was thrown.
-    //
-    // The most common types that will cause this exception are `Symbol` instances
-    // and Temporal objects like `Temporal.Instant`. But any object that has a
-    // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
-    // exception. (Library authors do this to prevent users from using built-in
-    // numeric operators like `+` or comparison operators like `>=` because custom
-    // methods are needed to perform accurate arithmetic or comparison.)
-    //
-    // To fix the problem, coerce this object or symbol value to a string before
-    // passing it to React. The most reliable way is usually `String(value)`.
-    //
-    // To find which value is throwing, check the browser or debugger console.
-    // Before this exception was thrown, there should be `console.error` output
-    // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
-    // problem and how that type was used: key, atrribute, input value prop, etc.
-    // In most cases, this console output also shows the component and its
-    // ancestor components where the exception happened.
-    //
-    // eslint-disable-next-line react-internal/safe-string-coercion
-    return '' + value;
-  }
-  function checkKeyStringCoercion(value) {
-    {
-      if (willCoercionThrow()) {
-        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)
-      }
-    }
-  }
-
   function getWrappedName(outerType, innerType, wrapperName) {
-    var displayName = outerType.displayName;
-
-    if (displayName) {
-      return displayName;
-    }
-
     var functionName = innerType.displayName || innerType.name || '';
-    return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
-  } // Keep in sync with react-reconciler/getComponentNameFromFiber
-
+    return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+  }
 
   function getContextName(type) {
     return type.displayName || 'Context';
-  } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
-
+  }
 
-  function getComponentNameFromType(type) {
+  function getComponentName(type) {
     if (type == null) {
       // Host root, text node or just invalid type.
       return null;
@@ -50005,7 +50028,7 @@
 
     {
       if (typeof type.tag === 'number') {
-        error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+        error('Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
       }
     }
 
@@ -50018,24 +50041,23 @@
     }
 
     switch (type) {
-      case REACT_FRAGMENT_TYPE:
+      case exports.Fragment:
         return 'Fragment';
 
       case REACT_PORTAL_TYPE:
         return 'Portal';
 
-      case REACT_PROFILER_TYPE:
+      case exports.Profiler:
         return 'Profiler';
 
-      case REACT_STRICT_MODE_TYPE:
+      case exports.StrictMode:
         return 'StrictMode';
 
-      case REACT_SUSPENSE_TYPE:
+      case exports.Suspense:
         return 'Suspense';
 
       case REACT_SUSPENSE_LIST_TYPE:
         return 'SuspenseList';
-
     }
 
     if (typeof type === 'object') {
@@ -50052,13 +50074,10 @@
           return getWrappedName(type, type.render, 'ForwardRef');
 
         case REACT_MEMO_TYPE:
-          var outerName = type.displayName || null;
-
-          if (outerName !== null) {
-            return outerName;
-          }
+          return getComponentName(type.type);
 
-          return getComponentNameFromType(type.type) || 'Memo';
+        case REACT_BLOCK_TYPE:
+          return getComponentName(type._render);
 
         case REACT_LAZY_TYPE:
           {
@@ -50067,13 +50086,11 @@
             var init = lazyComponent._init;
 
             try {
-              return getComponentNameFromType(init(payload));
+              return getComponentName(init(payload));
             } catch (x) {
               return null;
             }
           }
-
-        // eslint-disable-next-line no-fallthrough
       }
     }
 
@@ -50081,7 +50098,6 @@
   }
 
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-
   var RESERVED_PROPS = {
     key: true,
     ref: true,
@@ -50161,7 +50177,7 @@
   function warnIfStringRefCannotBeAutoConverted(config) {
     {
       if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
-        var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+        var componentName = getComponentName(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);
@@ -50270,10 +50286,6 @@
       }
 
       if (hasValidKey(config)) {
-        {
-          checkKeyStringCoercion(config.key);
-        }
-
         key = '' + config.key;
       }
 
@@ -50346,13 +50358,16 @@
    */
 
   function cloneElement(element, config, children) {
-    if (element === null || element === undefined) {
-      throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+    if (!!(element === null || element === undefined)) {
+      {
+        throw Error( "React.cloneElement(...): The argument must be a React element, but you passed " + element + "." );
+      }
     }
 
     var propName; // Original props are copied
 
-    var props = assign({}, element.props); // Reserved names are extracted
+    var props = _assign({}, element.props); // Reserved names are extracted
+
 
     var key = element.key;
     var ref = element.ref; // Self is preserved since the owner is preserved.
@@ -50373,10 +50388,6 @@
       }
 
       if (hasValidKey(config)) {
-        {
-          checkKeyStringCoercion(config.key);
-        }
-
         key = '' + config.key;
       } // Remaining properties override existing props
 
@@ -50475,10 +50486,6 @@
     // that we don't block potential future ES APIs.
     if (typeof element === 'object' && element !== null && element.key != null) {
       // Explicit key
-      {
-        checkKeyStringCoercion(element.key);
-      }
-
       return escape('' + element.key);
     } // Implicit key determined by the index in the set
 
@@ -50522,7 +50529,7 @@
 
       var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
 
-      if (isArray(mappedChild)) {
+      if (Array.isArray(mappedChild)) {
         var escapedChildKey = '';
 
         if (childKey != null) {
@@ -50534,20 +50541,10 @@
         });
       } 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, // Keep both the (mapped) and old keys if they differ, just as
           // traverseAllChildren used to do for objects as children
           escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
           mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
-          // eslint-disable-next-line react-internal/safe-string-coercion
           escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey);
         }
 
@@ -50563,7 +50560,7 @@
 
     var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
 
-    if (isArray(children)) {
+    if (Array.isArray(children)) {
       for (var i = 0; i < children.length; i++) {
         child = children[i];
         nextName = nextNamePrefix + getElementKey(child, i);
@@ -50596,9 +50593,13 @@
           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.');
+        var childrenString = '' + children;
+
+        {
+          {
+            throw 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." );
+          }
+        }
       }
     }
 
@@ -50697,17 +50698,28 @@
 
   function onlyChild(children) {
     if (!isValidElement(children)) {
-      throw new Error('React.Children.only expected to receive a single React element child.');
+      {
+        throw Error( "React.Children.only expected to receive a single React element child." );
+      }
     }
 
     return children;
   }
 
-  function createContext(defaultValue) {
-    // TODO: Second argument used to be an optional `calculateChangedBits`
-    // function. Warn to reserve for future use?
+  function createContext(defaultValue, calculateChangedBits) {
+    if (calculateChangedBits === undefined) {
+      calculateChangedBits = null;
+    } else {
+      {
+        if (calculateChangedBits !== null && typeof calculateChangedBits !== 'function') {
+          error('createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits);
+        }
+      }
+    }
+
     var context = {
       $$typeof: REACT_CONTEXT_TYPE,
+      _calculateChangedBits: calculateChangedBits,
       // As a workaround to support multiple concurrent renderers, we categorize
       // some renderers as primary and others as secondary. We only expect
       // there to be two concurrent renderers at most: React Native (primary) and
@@ -50720,10 +50732,7 @@
       _threadCount: 0,
       // These are circular
       Provider: null,
-      Consumer: null,
-      // Add these to use same hidden class in VM as ServerContext
-      _defaultValue: null,
-      _globalName: null
+      Consumer: null
     };
     context.Provider = {
       $$typeof: REACT_PROVIDER_TYPE,
@@ -50739,7 +50748,8 @@
       // warn for the incorrect usage of Context as a Consumer.
       var Consumer = {
         $$typeof: REACT_CONTEXT_TYPE,
-        _context: context
+        _context: context,
+        _calculateChangedBits: context._calculateChangedBits
       }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
 
       Object.defineProperties(Consumer, {
@@ -50826,54 +50836,38 @@
     if (payload._status === Uninitialized) {
       var ctor = payload._result;
       var thenable = ctor(); // Transition to the next state.
-      // This might throw either because it's missing or throws. If so, we treat it
-      // as still uninitialized and try again next time. Which is the same as what
-      // happens if the ctor or any wrappers processing the ctor throws. This might
-      // end up fixing it if the resolution was a concurrency bug.
 
+      var pending = payload;
+      pending._status = Pending;
+      pending._result = thenable;
       thenable.then(function (moduleObject) {
-        if (payload._status === Pending || payload._status === Uninitialized) {
-          // Transition to the next state.
+        if (payload._status === Pending) {
+          var defaultExport = moduleObject.default;
+
+          {
+            if (defaultExport === undefined) {
+              error('lazy: Expected the result of a dynamic import() 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);
+            }
+          } // Transition to the next state.
+
+
           var resolved = payload;
           resolved._status = Resolved;
-          resolved._result = moduleObject;
+          resolved._result = defaultExport;
         }
       }, function (error) {
-        if (payload._status === Pending || payload._status === Uninitialized) {
+        if (payload._status === Pending) {
           // Transition to the next state.
           var rejected = payload;
           rejected._status = Rejected;
           rejected._result = error;
         }
       });
-
-      if (payload._status === Uninitialized) {
-        // In case, we're still uninitialized, then we're waiting for the thenable
-        // to resolve. Set it as pending in the meantime.
-        var pending = payload;
-        pending._status = Pending;
-        pending._result = thenable;
-      }
     }
 
     if (payload._status === Resolved) {
-      var moduleObject = payload._result;
-
-      {
-        if (moduleObject === undefined) {
-          error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
-          'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject);
-        }
-      }
-
-      {
-        if (!('default' in moduleObject)) {
-          error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
-          'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject);
-        }
-      }
-
-      return moduleObject.default;
+      return payload._result;
     } else {
       throw payload._result;
     }
@@ -50882,7 +50876,7 @@
   function lazy(ctor) {
     var payload = {
       // We use these fields to store the result.
-      _status: Uninitialized,
+      _status: -1,
       _result: ctor
     };
     var lazyType = {
@@ -50968,15 +50962,9 @@
           return ownName;
         },
         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,
-          // so that our component-stack generation logic will display their frames.
-          // An anonymous function generally suggests a pattern like:
-          //   React.forwardRef((props, ref) => {...});
-          // This kind of inner function is not used elsewhere so the side effect is okay.
-
-          if (!render.name && !render.displayName) {
+          ownName = name;
+
+          if (render.displayName == null) {
             render.displayName = name;
           }
         }
@@ -50986,11 +50974,9 @@
     return elementType;
   }
 
-  var REACT_MODULE_REFERENCE;
+  // Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
 
-  {
-    REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
-  }
+  var enableScopeAPI = false; // Experimental Create Event Handle API.
 
   function isValidElementType(type) {
     if (typeof type === 'string' || typeof type === 'function') {
@@ -50998,16 +50984,12 @@
     } // 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 ) {
+    if (type === exports.Fragment || type === exports.Profiler || type === REACT_DEBUG_TRACING_MODE_TYPE || type === exports.StrictMode || type === exports.Suspense || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI ) {
       return true;
     }
 
     if (typeof type === 'object' && type !== null) {
-      if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
-      // types supported by any Flight configuration anywhere since
-      // we don't know which Flight build this will end up being used
-      // with.
-      type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+      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 || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
         return true;
       }
     }
@@ -51037,15 +51019,9 @@
           return ownName;
         },
         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,
-          // so that our component-stack generation logic will display their frames.
-          // An anonymous function generally suggests a pattern like:
-          //   React.memo((props) => {...});
-          // This kind of inner function is not used elsewhere so the side effect is okay.
-
-          if (!type.name && !type.displayName) {
+          ownName = name;
+
+          if (type.displayName == null) {
             type.displayName = name;
           }
         }
@@ -51058,22 +51034,24 @@
   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.');
+    if (!(dispatcher !== null)) {
+      {
+        throw 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:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem." );
       }
-    } // Will result in a null access error if accessed outside render phase. We
-    // intentionally don't throw our own error because this is in a hot path.
-    // Also helps ensure this is inlined.
-
+    }
 
     return dispatcher;
   }
-  function useContext(Context) {
+
+  function useContext(Context, unstable_observedBits) {
     var dispatcher = resolveDispatcher();
 
     {
-      // TODO: add a more generic warning for invalid values.
+      if (unstable_observedBits !== undefined) {
+        error('useContext() second argument is reserved for future ' + 'use in React. Passing it is not supported. ' + 'You passed: %s.%s', unstable_observedBits, typeof unstable_observedBits === 'number' && Array.isArray(arguments[2]) ? '\n\nDid you call array.map(useContext)? ' + 'Calling Hooks inside a loop is not supported. ' + 'Learn more at https://reactjs.org/link/rules-of-hooks' : '');
+      } // TODO: add a more generic warning for invalid values.
+
+
       if (Context._context !== undefined) {
         var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
         // and nobody should be using this in existing code.
@@ -51086,7 +51064,7 @@
       }
     }
 
-    return dispatcher.useContext(Context);
+    return dispatcher.useContext(Context, unstable_observedBits);
   }
   function useState(initialState) {
     var dispatcher = resolveDispatcher();
@@ -51104,10 +51082,6 @@
     var dispatcher = resolveDispatcher();
     return dispatcher.useEffect(create, deps);
   }
-  function useInsertionEffect(create, deps) {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useInsertionEffect(create, deps);
-  }
   function useLayoutEffect(create, deps) {
     var dispatcher = resolveDispatcher();
     return dispatcher.useLayoutEffect(create, deps);
@@ -51130,22 +51104,6 @@
       return dispatcher.useDebugValue(value, formatterFn);
     }
   }
-  function useTransition() {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useTransition();
-  }
-  function useDeferredValue(value) {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useDeferredValue(value);
-  }
-  function useId() {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useId();
-  }
-  function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-  }
 
   // Helpers to patch console.logs to avoid logging during side-effect free
   // replaying on render function. This currently only patches the object
@@ -51210,25 +51168,25 @@
         }; // $FlowFixMe Flow thinks console is immutable.
 
         Object.defineProperties(console, {
-          log: assign({}, props, {
+          log: _assign({}, props, {
             value: prevLog
           }),
-          info: assign({}, props, {
+          info: _assign({}, props, {
             value: prevInfo
           }),
-          warn: assign({}, props, {
+          warn: _assign({}, props, {
             value: prevWarn
           }),
-          error: assign({}, props, {
+          error: _assign({}, props, {
             value: prevError
           }),
-          group: assign({}, props, {
+          group: _assign({}, props, {
             value: prevGroup
           }),
-          groupCollapsed: assign({}, props, {
+          groupCollapsed: _assign({}, props, {
             value: prevGroupCollapsed
           }),
-          groupEnd: assign({}, props, {
+          groupEnd: _assign({}, props, {
             value: prevGroupEnd
           })
         });
@@ -51269,7 +51227,7 @@
 
   function describeNativeComponentFrame(fn, construct) {
     // If something asked for a stack inside a fake render, it should get ignored.
-    if ( !fn || reentry) {
+    if (!fn || reentry) {
       return '';
     }
 
@@ -51378,14 +51336,7 @@
 
                 if (c < 0 || sampleLines[s] !== controlLines[c]) {
                   // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
-                  var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
-                  // but we have a user-provided "displayName"
-                  // splice it in to make the stack more readable.
-
-
-                  if (fn.displayName && _frame.includes('<anonymous>')) {
-                    _frame = _frame.replace('<anonymous>', fn.displayName);
-                  }
+                  var _frame = '\n' + sampleLines[s].replace(' at new ', ' at ');
 
                   {
                     if (typeof fn === 'function') {
@@ -51454,7 +51405,7 @@
     }
 
     switch (type) {
-      case REACT_SUSPENSE_TYPE:
+      case exports.Suspense:
         return describeBuiltInComponentFrame('Suspense');
 
       case REACT_SUSPENSE_LIST_TYPE:
@@ -51470,6 +51421,9 @@
           // Memo may contain any component type so we recursively resolve it.
           return describeUnknownElementTypeFrameInDEV(type.type);
 
+        case REACT_BLOCK_TYPE:
+          return describeFunctionComponentFrame(type._render);
+
         case REACT_LAZY_TYPE:
           {
             var lazyComponent = type;
@@ -51504,7 +51458,7 @@
   function checkPropTypes(typeSpecs, values, location, componentName, element) {
     {
       // $FlowFixMe This is okay but Flow doesn't know it.
-      var has = Function.call.bind(hasOwnProperty);
+      var has = Function.call.bind(Object.prototype.hasOwnProperty);
 
       for (var typeSpecName in typeSpecs) {
         if (has(typeSpecs, typeSpecName)) {
@@ -51516,7 +51470,6 @@
             // This is intentionally an invariant that gets caught. It's the same
             // behavior as without this statement except with a better message.
             if (typeof typeSpecs[typeSpecName] !== 'function') {
-              // eslint-disable-next-line react-internal/prod-error-codes
               var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
               err.name = 'Invariant Violation';
               throw err;
@@ -51569,7 +51522,7 @@
 
   function getDeclarationErrorAddendum() {
     if (ReactCurrentOwner.current) {
-      var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+      var name = getComponentName(ReactCurrentOwner.current.type);
 
       if (name) {
         return '\n\nCheck the render method of `' + name + '`.';
@@ -51651,7 +51604,7 @@
 
     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) + ".";
+      childOwner = " It was passed a child from " + getComponentName(element._owner.type) + ".";
     }
 
     {
@@ -51678,7 +51631,7 @@
       return;
     }
 
-    if (isArray(node)) {
+    if (Array.isArray(node)) {
       for (var i = 0; i < node.length; i++) {
         var child = node[i];
 
@@ -51740,12 +51693,12 @@
 
       if (propTypes) {
         // Intentionally inside to avoid triggering lazy initializers:
-        var name = getComponentNameFromType(type);
+        var name = getComponentName(type);
         checkPropTypes(propTypes, element.props, 'prop', name, element);
       } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
         propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
 
-        var _name = getComponentNameFromType(type);
+        var _name = getComponentName(type);
 
         error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
       }
@@ -51810,10 +51763,10 @@
 
       if (type === null) {
         typeString = 'null';
-      } else if (isArray(type)) {
+      } else if (Array.isArray(type)) {
         typeString = 'array';
       } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
-        typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+        typeString = "<" + (getComponentName(type.type) || 'Unknown') + " />";
         info = ' Did you accidentally export a JSX literal instead of a component?';
       } else {
         typeString = typeof type;
@@ -51842,7 +51795,7 @@
       }
     }
 
-    if (type === REACT_FRAGMENT_TYPE) {
+    if (type === exports.Fragment) {
       validateFragmentProps(element);
     } else {
       validatePropTypes(element);
@@ -51889,263 +51842,12 @@
     return newElement;
   }
 
-  function startTransition(scope, options) {
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = {};
-    var currentTransition = ReactCurrentBatchConfig.transition;
-
-    {
-      ReactCurrentBatchConfig.transition._updatedFibers = new Set();
-    }
+  {
 
     try {
-      scope();
-    } finally {
-      ReactCurrentBatchConfig.transition = prevTransition;
-
-      {
-        if (prevTransition === null && currentTransition._updatedFibers) {
-          var updatedFibersCount = currentTransition._updatedFibers.size;
-
-          if (updatedFibersCount > 10) {
-            warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.');
-          }
-
-          currentTransition._updatedFibers.clear();
-        }
-      }
-    }
-  }
-
-  var 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 nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
-        // version of setImmediate, bypassing fake timers if any.
-
-        enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
-      } catch (_err) {
-        // we're in a browser
-        // we can't use regular timers because they may still be faked
-        // so we try MessageChannel+postMessage instead
-        enqueueTaskImpl = function (callback) {
-          {
-            if (didWarnAboutMessageChannel === false) {
-              didWarnAboutMessageChannel = true;
-
-              if (typeof MessageChannel === 'undefined') {
-                error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
-              }
-            }
-          }
-
-          var channel = new MessageChannel();
-          channel.port1.onmessage = callback;
-          channel.port2.postMessage(undefined);
-        };
-      }
-    }
-
-    return enqueueTaskImpl(task);
-  }
-
-  var 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.
-      var prevActScopeDepth = actScopeDepth;
-      actScopeDepth++;
-
-      if (ReactCurrentActQueue.current === null) {
-        // This is the outermost `act` scope. Initialize the queue. The reconciler
-        // will detect the queue and use it instead of Scheduler.
-        ReactCurrentActQueue.current = [];
-      }
-
-      var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
-      var result;
-
-      try {
-        // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
-        // set to `true` while the given callback is executed, not for updates
-        // triggered during an async event, because this is how the legacy
-        // implementation of `act` behaved.
-        ReactCurrentActQueue.isBatchingLegacy = true;
-        result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
-        // which flushed updates immediately after the scope function exits, even
-        // if it's an async function.
-
-        if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
-          var queue = ReactCurrentActQueue.current;
-
-          if (queue !== null) {
-            ReactCurrentActQueue.didScheduleLegacyUpdate = false;
-            flushActQueue(queue);
-          }
-        }
-      } catch (error) {
-        popActScope(prevActScopeDepth);
-        throw error;
-      } finally {
-        ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
-      }
-
-      if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
-        var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
-        // for it to resolve before exiting the current scope.
-
-        var wasAwaited = false;
-        var thenable = {
-          then: function (resolve, reject) {
-            wasAwaited = true;
-            thenableResult.then(function (returnValue) {
-              popActScope(prevActScopeDepth);
-
-              if (actScopeDepth === 0) {
-                // We've exited the outermost act scope. Recursively flush the
-                // queue until there's no remaining work.
-                recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-              } else {
-                resolve(returnValue);
-              }
-            }, function (error) {
-              // The callback threw an error.
-              popActScope(prevActScopeDepth);
-              reject(error);
-            });
-          }
-        };
-
-        {
-          if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {
-            // eslint-disable-next-line no-undef
-            Promise.resolve().then(function () {}).then(function () {
-              if (!wasAwaited) {
-                didWarnNoAwaitAct = true;
-
-                error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');
-              }
-            });
-          }
-        }
-
-        return thenable;
-      } else {
-        var returnValue = result; // The callback is not an async function. Exit the current scope
-        // immediately, without awaiting.
-
-        popActScope(prevActScopeDepth);
-
-        if (actScopeDepth === 0) {
-          // Exiting the outermost act scope. Flush the queue.
-          var _queue = ReactCurrentActQueue.current;
-
-          if (_queue !== null) {
-            flushActQueue(_queue);
-            ReactCurrentActQueue.current = null;
-          } // Return a thenable. If the user awaits it, we'll flush again in
-          // case additional work was scheduled by a microtask.
-
-
-          var _thenable = {
-            then: function (resolve, reject) {
-              // Confirm we haven't re-entered another `act` scope, in case
-              // the user does something weird like await the thenable
-              // multiple times.
-              if (ReactCurrentActQueue.current === null) {
-                // Recursively flush the queue until there's no remaining work.
-                ReactCurrentActQueue.current = [];
-                recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-              } else {
-                resolve(returnValue);
-              }
-            }
-          };
-          return _thenable;
-        } else {
-          // Since we're inside a nested `act` scope, the returned thenable
-          // immediately resolves. The outer scope will flush the queue.
-          var _thenable2 = {
-            then: function (resolve, reject) {
-              resolve(returnValue);
-            }
-          };
-          return _thenable2;
-        }
-      }
-    }
-  }
-
-  function popActScope(prevActScopeDepth) {
-    {
-      if (prevActScopeDepth !== actScopeDepth - 1) {
-        error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
-      }
-
-      actScopeDepth = prevActScopeDepth;
-    }
-  }
-
-  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.
-        isFlushing = true;
-        var i = 0;
-
-        try {
-          for (; i < queue.length; i++) {
-            var callback = queue[i];
-
-            do {
-              callback = callback(true);
-            } while (callback !== null);
-          }
-
-          queue.length = 0;
-        } catch (error) {
-          // If something throws, leave the remaining callbacks on the queue.
-          queue = queue.slice(i + 1);
-          throw error;
-        } finally {
-          isFlushing = false;
-        }
-      }
+      Object.freeze({});
+      /* eslint-enable no-new */
+    } catch (e) {
     }
   }
 
@@ -52162,11 +51864,7 @@
 
   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;
@@ -52177,33 +51875,17 @@
   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());
-  }
-          
     })();
   }
   });