/**

 * @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 (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :

  typeof define === 'function' && define.amd ? define(['exports'], factory) :

  (global = global || self, factory(global.React = {}));

}(this, (function (exports) { 'use strict';

  var ReactVersion = '18.3.1';

  // 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') {

      return maybeIterator;

    }

    return null;

  }

  /**

   * 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;

  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

  };

  {

    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.

  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);

      }

    }

  }

  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);

      }

    }

  }

  function printWarning(level, format, args) {

    // When changing this logic, you might want to also

    // update consoleWithStackDev.www.js as well.

    {

      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;

      var stack = ReactDebugCurrentFrame.getStackAddendum();

      if (stack !== '') {

        format += '%s';

        args = args.concat([stack]);

      } // eslint-disable-next-line react-internal/safe-string-coercion

      var argsWithFormat = args.map(function (item) {

        return String(item);

      }); // Careful: RN currently depends on this prefix

      argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it

      // breaks IE9: https://github.com/facebook/react/issues/13610

      // eslint-disable-next-line react-internal/no-production-logging

      Function.prototype.apply.call(console[level], console, argsWithFormat);

    }

  }

  var didWarnStateUpdateForUnmountedComponent = {};

  function warnNoop(publicInstance, callerName) {

    {

      var _constructor = publicInstance.constructor;

      var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';

      var warningKey = componentName + "." + callerName;

      if (didWarnStateUpdateForUnmountedComponent[warningKey]) {

        return;

      }

      error("Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);

      didWarnStateUpdateForUnmountedComponent[warningKey] = true;

    }

  }

  /**

   * 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 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;

    this.context = context; // If a component has string refs, we will assign a different object later.

    this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the

    // renderer.

    this.updater = updater || ReactNoopUpdateQueue;

  }

  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 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

    };

    {

      Object.seal(refObject);

    }

    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 {

        testStringCoercion(value);

        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(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));