@raspberrypifoundation/design-system-react 0.1.3

package/dist/cjs/bundle.js

@@ -0,0 +1,3945 @@
+'use strict';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var classnames$1 = {exports: {}};
+
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+
+(function (module) {
+	/* global define */
+
+	(function () {
+
+		var hasOwn = {}.hasOwnProperty;
+
+		function classNames() {
+			var classes = [];
+
+			for (var i = 0; i < arguments.length; i++) {
+				var arg = arguments[i];
+				if (!arg) continue;
+
+				var argType = typeof arg;
+
+				if (argType === 'string' || argType === 'number') {
+					classes.push(arg);
+				} else if (Array.isArray(arg)) {
+					if (arg.length) {
+						var inner = classNames.apply(null, arg);
+						if (inner) {
+							classes.push(inner);
+						}
+					}
+				} else if (argType === 'object') {
+					if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+						classes.push(arg.toString());
+						continue;
+					}
+
+					for (var key in arg) {
+						if (hasOwn.call(arg, key) && arg[key]) {
+							classes.push(key);
+						}
+					}
+				}
+			}
+
+			return classes.join(' ');
+		}
+
+		if (module.exports) {
+			classNames.default = classNames;
+			module.exports = classNames;
+		} else {
+			window.classNames = classNames;
+		}
+	}()); 
+} (classnames$1));
+
+var classnamesExports = classnames$1.exports;
+var classnames = /*@__PURE__*/getDefaultExportFromCjs(classnamesExports);
+
+var propTypes = {exports: {}};
+
+var reactIs = {exports: {}};
+
+var reactIs_development = {};
+
+/** @license React v16.13.1
+ * react-is.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() {
+
+// 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 hasSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+// (unstable) APIs that have been removed. Can we remove the symbols?
+
+var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+function isValidElementType(type) {
+  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (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_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_ASYNC_MODE_TYPE:
+          case REACT_CONCURRENT_MODE_TYPE:
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+} // AsyncMode is deprecated along with isAsyncMode
+
+var AsyncMode = REACT_ASYNC_MODE_TYPE;
+var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+    }
+  }
+
+  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+}
+function isConcurrentMode(object) {
+  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+
+reactIs_development.AsyncMode = AsyncMode;
+reactIs_development.ConcurrentMode = ConcurrentMode;
+reactIs_development.ContextConsumer = ContextConsumer;
+reactIs_development.ContextProvider = ContextProvider;
+reactIs_development.Element = Element;
+reactIs_development.ForwardRef = ForwardRef;
+reactIs_development.Fragment = Fragment;
+reactIs_development.Lazy = Lazy;
+reactIs_development.Memo = Memo;
+reactIs_development.Portal = Portal;
+reactIs_development.Profiler = Profiler;
+reactIs_development.StrictMode = StrictMode;
+reactIs_development.Suspense = Suspense;
+reactIs_development.isAsyncMode = isAsyncMode;
+reactIs_development.isConcurrentMode = isConcurrentMode;
+reactIs_development.isContextConsumer = isContextConsumer;
+reactIs_development.isContextProvider = isContextProvider;
+reactIs_development.isElement = isElement;
+reactIs_development.isForwardRef = isForwardRef;
+reactIs_development.isFragment = isFragment;
+reactIs_development.isLazy = isLazy;
+reactIs_development.isMemo = isMemo;
+reactIs_development.isPortal = isPortal;
+reactIs_development.isProfiler = isProfiler;
+reactIs_development.isStrictMode = isStrictMode;
+reactIs_development.isSuspense = isSuspense;
+reactIs_development.isValidElementType = isValidElementType;
+reactIs_development.typeOf = typeOf;
+  })();
+}
+
+{
+  reactIs.exports = reactIs_development;
+}
+
+var reactIsExports = reactIs.exports;
+
+/*
+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;
+};
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var ReactPropTypesSecret$2 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+var ReactPropTypesSecret_1 = ReactPropTypesSecret$2;
+
+var has$2 = Function.call.bind(Object.prototype.hasOwnProperty);
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var printWarning$1 = function() {};
+
+{
+  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
+  var loggedTypeFailures = {};
+  var has$1 = has$2;
+
+  printWarning$1 = function(text) {
+    var message = 'Warning: ' + text;
+    if (typeof console !== 'undefined') {
+      console.error(message);
+    }
+    try {
+      // --- Welcome to debugging React ---
+      // This error was thrown as a convenience so that you can use this stack
+      // to find the callsite that caused this warning to fire.
+      throw new Error(message);
+    } catch (x) { /**/ }
+  };
+}
+
+/**
+ * Assert that the values match with the type specs.
+ * Error messages are memorized and will only be shown once.
+ *
+ * @param {object} typeSpecs Map of name to a ReactPropType
+ * @param {object} values Runtime values that need to be type-checked
+ * @param {string} location e.g. "prop", "context", "child context"
+ * @param {string} componentName Name of the component for error messages.
+ * @param {?Function} getStack Returns the component stack.
+ * @private
+ */
+function checkPropTypes$1(typeSpecs, values, location, componentName, getStack) {
+  {
+    for (var typeSpecName in typeSpecs) {
+      if (has$1(typeSpecs, typeSpecName)) {
+        var error;
+        // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== 'function') {
+            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 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
+        } catch (ex) {
+          error = ex;
+        }
+        if (error && !(error instanceof Error)) {
+          printWarning$1(
+            (componentName || 'React class') + ': type specification of ' +
+            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+            'You may have forgotten to pass an argument to the type checker ' +
+            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+            'shape all require an argument).'
+          );
+        }
+        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error.message] = true;
+
+          var stack = getStack ? getStack() : '';
+
+          printWarning$1(
+            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Resets warning cache when testing.
+ *
+ * @private
+ */
+checkPropTypes$1.resetWarningCache = function() {
+  {
+    loggedTypeFailures = {};
+  }
+};
+
+var checkPropTypes_1 = checkPropTypes$1;
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var ReactIs$1 = reactIsExports;
+var assign = objectAssign;
+
+var ReactPropTypesSecret = ReactPropTypesSecret_1;
+var has = has$2;
+var checkPropTypes = checkPropTypes_1;
+
+var printWarning = function() {};
+
+{
+  printWarning = function(text) {
+    var message = 'Warning: ' + text;
+    if (typeof console !== 'undefined') {
+      console.error(message);
+    }
+    try {
+      // --- Welcome to debugging React ---
+      // This error was thrown as a convenience so that you can use this stack
+      // to find the callsite that caused this warning to fire.
+      throw new Error(message);
+    } catch (x) {}
+  };
+}
+
+function emptyFunctionThatReturnsNull() {
+  return null;
+}
+
+var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
+  /* global Symbol */
+  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+  /**
+   * Returns the iterator method function contained on the iterable object.
+   *
+   * Be sure to invoke the function with the iterable as context:
+   *
+   *     var iteratorFn = getIteratorFn(myIterable);
+   *     if (iteratorFn) {
+   *       var iterator = iteratorFn.call(myIterable);
+   *       ...
+   *     }
+   *
+   * @param {?object} maybeIterable
+   * @return {?function}
+   */
+  function getIteratorFn(maybeIterable) {
+    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+    if (typeof iteratorFn === 'function') {
+      return iteratorFn;
+    }
+  }
+
+  /**
+   * Collection of methods that allow declaration and validation of props that are
+   * supplied to React components. Example usage:
+   *
+   *   var Props = require('ReactPropTypes');
+   *   var MyArticle = React.createClass({
+   *     propTypes: {
+   *       // An optional string prop named "description".
+   *       description: Props.string,
+   *
+   *       // A required enum prop named "category".
+   *       category: Props.oneOf(['News','Photos']).isRequired,
+   *
+   *       // A prop named "dialog" that requires an instance of Dialog.
+   *       dialog: Props.instanceOf(Dialog).isRequired
+   *     },
+   *     render: function() { ... }
+   *   });
+   *
+   * A more formal specification of how these methods are used:
+   *
+   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+   *   decl := ReactPropTypes.{type}(.isRequired)?
+   *
+   * Each and every declaration produces a function with the same signature. This
+   * allows the creation of custom validation functions. For example:
+   *
+   *  var MyLink = React.createClass({
+   *    propTypes: {
+   *      // An optional string or URI prop named "href".
+   *      href: function(props, propName, componentName) {
+   *        var propValue = props[propName];
+   *        if (propValue != null && typeof propValue !== 'string' &&
+   *            !(propValue instanceof URI)) {
+   *          return new Error(
+   *            'Expected a string or an URI for ' + propName + ' in ' +
+   *            componentName
+   *          );
+   *        }
+   *      }
+   *    },
+   *    render: function() {...}
+   *  });
+   *
+   * @internal
+   */
+
+  var ANONYMOUS = '<<anonymous>>';
+
+  // Important!
+  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+  var ReactPropTypes = {
+    array: createPrimitiveTypeChecker('array'),
+    bigint: createPrimitiveTypeChecker('bigint'),
+    bool: createPrimitiveTypeChecker('boolean'),
+    func: createPrimitiveTypeChecker('function'),
+    number: createPrimitiveTypeChecker('number'),
+    object: createPrimitiveTypeChecker('object'),
+    string: createPrimitiveTypeChecker('string'),
+    symbol: createPrimitiveTypeChecker('symbol'),
+
+    any: createAnyTypeChecker(),
+    arrayOf: createArrayOfTypeChecker,
+    element: createElementTypeChecker(),
+    elementType: createElementTypeTypeChecker(),
+    instanceOf: createInstanceTypeChecker,
+    node: createNodeChecker(),
+    objectOf: createObjectOfTypeChecker,
+    oneOf: createEnumTypeChecker,
+    oneOfType: createUnionTypeChecker,
+    shape: createShapeTypeChecker,
+    exact: createStrictShapeTypeChecker,
+  };
+
+  /**
+   * inlined Object.is polyfill to avoid requiring consumers ship their own
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+   */
+  /*eslint-disable no-self-compare*/
+  function is(x, y) {
+    // SameValue algorithm
+    if (x === y) {
+      // Steps 1-5, 7-10
+      // Steps 6.b-6.e: +0 != -0
+      return x !== 0 || 1 / x === 1 / y;
+    } else {
+      // Step 6.a: NaN == NaN
+      return x !== x && y !== y;
+    }
+  }
+  /*eslint-enable no-self-compare*/
+
+  /**
+   * We use an Error-like object for backward compatibility as people may call
+   * PropTypes directly and inspect their output. However, we don't use real
+   * Errors anymore. We don't inspect their stack anyway, and creating them
+   * is prohibitively expensive if they are created too often, such as what
+   * happens in oneOfType() for any type before the one that matched.
+   */
+  function PropTypeError(message, data) {
+    this.message = message;
+    this.data = data && typeof data === 'object' ? data: {};
+    this.stack = '';
+  }
+  // Make `instanceof Error` still work for returned errors.
+  PropTypeError.prototype = Error.prototype;
+
+  function createChainableTypeChecker(validate) {
+    {
+      var manualPropTypeCallCache = {};
+      var manualPropTypeWarningCount = 0;
+    }
+    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+      componentName = componentName || ANONYMOUS;
+      propFullName = propFullName || propName;
+
+      if (secret !== ReactPropTypesSecret) {
+        if (throwOnDirectAccess) {
+          // New behavior only for users of `prop-types` package
+          var err = new Error(
+            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+            'Use `PropTypes.checkPropTypes()` to call them. ' +
+            'Read more at http://fb.me/use-check-prop-types'
+          );
+          err.name = 'Invariant Violation';
+          throw err;
+        } else if (typeof console !== 'undefined') {
+          // Old behavior for people using React.PropTypes
+          var cacheKey = componentName + ':' + propName;
+          if (
+            !manualPropTypeCallCache[cacheKey] &&
+            // Avoid spamming the console because they are often not actionable except for lib authors
+            manualPropTypeWarningCount < 3
+          ) {
+            printWarning(
+              'You are manually calling a React.PropTypes validation ' +
+              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
+              'and will throw in the standalone `prop-types` package. ' +
+              'You may be seeing this warning due to a third-party PropTypes ' +
+              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
+            );
+            manualPropTypeCallCache[cacheKey] = true;
+            manualPropTypeWarningCount++;
+          }
+        }
+      }
+      if (props[propName] == null) {
+        if (isRequired) {
+          if (props[propName] === null) {
+            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+          }
+          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+        }
+        return null;
+      } else {
+        return validate(props, propName, componentName, location, propFullName);
+      }
+    }
+
+    var chainedCheckType = checkType.bind(null, false);
+    chainedCheckType.isRequired = checkType.bind(null, true);
+
+    return chainedCheckType;
+  }
+
+  function createPrimitiveTypeChecker(expectedType) {
+    function validate(props, propName, componentName, location, propFullName, secret) {
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== expectedType) {
+        // `propValue` being instance of, say, date/regexp, pass the 'object'
+        // check, but we can offer a more precise error message here rather than
+        // 'of type `object`'.
+        var preciseType = getPreciseType(propValue);
+
+        return new PropTypeError(
+          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
+          {expectedType: expectedType}
+        );
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createAnyTypeChecker() {
+    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+  }
+
+  function createArrayOfTypeChecker(typeChecker) {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (typeof typeChecker !== 'function') {
+        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+      }
+      var propValue = props[propName];
+      if (!Array.isArray(propValue)) {
+        var propType = getPropType(propValue);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+      }
+      for (var i = 0; i < propValue.length; i++) {
+        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+        if (error instanceof Error) {
+          return error;
+        }
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createElementTypeChecker() {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      if (!isValidElement(propValue)) {
+        var propType = getPropType(propValue);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createElementTypeTypeChecker() {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      if (!ReactIs$1.isValidElementType(propValue)) {
+        var propType = getPropType(propValue);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createInstanceTypeChecker(expectedClass) {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (!(props[propName] instanceof expectedClass)) {
+        var expectedClassName = expectedClass.name || ANONYMOUS;
+        var actualClassName = getClassName(props[propName]);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createEnumTypeChecker(expectedValues) {
+    if (!Array.isArray(expectedValues)) {
+      {
+        if (arguments.length > 1) {
+          printWarning(
+            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
+            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
+          );
+        } else {
+          printWarning('Invalid argument supplied to oneOf, expected an array.');
+        }
+      }
+      return emptyFunctionThatReturnsNull;
+    }
+
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      for (var i = 0; i < expectedValues.length; i++) {
+        if (is(propValue, expectedValues[i])) {
+          return null;
+        }
+      }
+
+      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+        var type = getPreciseType(value);
+        if (type === 'symbol') {
+          return String(value);
+        }
+        return value;
+      });
+      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createObjectOfTypeChecker(typeChecker) {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (typeof typeChecker !== 'function') {
+        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+      }
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== 'object') {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+      }
+      for (var key in propValue) {
+        if (has(propValue, key)) {
+          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+          if (error instanceof Error) {
+            return error;
+          }
+        }
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createUnionTypeChecker(arrayOfTypeCheckers) {
+    if (!Array.isArray(arrayOfTypeCheckers)) {
+      printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') ;
+      return emptyFunctionThatReturnsNull;
+    }
+
+    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+      var checker = arrayOfTypeCheckers[i];
+      if (typeof checker !== 'function') {
+        printWarning(
+          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
+          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
+        );
+        return emptyFunctionThatReturnsNull;
+      }
+    }
+
+    function validate(props, propName, componentName, location, propFullName) {
+      var expectedTypes = [];
+      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+        var checker = arrayOfTypeCheckers[i];
+        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+        if (checkerResult == null) {
+          return null;
+        }
+        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
+          expectedTypes.push(checkerResult.data.expectedType);
+        }
+      }
+      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
+      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createNodeChecker() {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (!isNode(props[propName])) {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function invalidValidatorError(componentName, location, propFullName, key, type) {
+    return new PropTypeError(
+      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
+      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
+    );
+  }
+
+  function createShapeTypeChecker(shapeTypes) {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== 'object') {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+      }
+      for (var key in shapeTypes) {
+        var checker = shapeTypes[key];
+        if (typeof checker !== 'function') {
+          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+        }
+        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+        if (error) {
+          return error;
+        }
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createStrictShapeTypeChecker(shapeTypes) {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== 'object') {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+      }
+      // We need to check all keys in case some are required but missing from props.
+      var allKeys = assign({}, props[propName], shapeTypes);
+      for (var key in allKeys) {
+        var checker = shapeTypes[key];
+        if (has(shapeTypes, key) && typeof checker !== 'function') {
+          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+        }
+        if (!checker) {
+          return new PropTypeError(
+            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
+            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
+            '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')
+          );
+        }
+        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+        if (error) {
+          return error;
+        }
+      }
+      return null;
+    }
+
+    return createChainableTypeChecker(validate);
+  }
+
+  function isNode(propValue) {
+    switch (typeof propValue) {
+      case 'number':
+      case 'string':
+      case 'undefined':
+        return true;
+      case 'boolean':
+        return !propValue;
+      case 'object':
+        if (Array.isArray(propValue)) {
+          return propValue.every(isNode);
+        }
+        if (propValue === null || isValidElement(propValue)) {
+          return true;
+        }
+
+        var iteratorFn = getIteratorFn(propValue);
+        if (iteratorFn) {
+          var iterator = iteratorFn.call(propValue);
+          var step;
+          if (iteratorFn !== propValue.entries) {
+            while (!(step = iterator.next()).done) {
+              if (!isNode(step.value)) {
+                return false;
+              }
+            }
+          } else {
+            // Iterator will provide entry [k,v] tuples rather than values.
+            while (!(step = iterator.next()).done) {
+              var entry = step.value;
+              if (entry) {
+                if (!isNode(entry[1])) {
+                  return false;
+                }
+              }
+            }
+          }
+        } else {
+          return false;
+        }
+
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  function isSymbol(propType, propValue) {
+    // Native Symbol.
+    if (propType === 'symbol') {
+      return true;
+    }
+
+    // falsy value can't be a Symbol
+    if (!propValue) {
+      return false;
+    }
+
+    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+    if (propValue['@@toStringTag'] === 'Symbol') {
+      return true;
+    }
+
+    // Fallback for non-spec compliant Symbols which are polyfilled.
+    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // Equivalent of `typeof` but with special handling for array and regexp.
+  function getPropType(propValue) {
+    var propType = typeof propValue;
+    if (Array.isArray(propValue)) {
+      return 'array';
+    }
+    if (propValue instanceof RegExp) {
+      // Old webkits (at least until Android 4.0) return 'function' rather than
+      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+      // passes PropTypes.object.
+      return 'object';
+    }
+    if (isSymbol(propType, propValue)) {
+      return 'symbol';
+    }
+    return propType;
+  }
+
+  // This handles more types than `getPropType`. Only used for error messages.
+  // See `createPrimitiveTypeChecker`.
+  function getPreciseType(propValue) {
+    if (typeof propValue === 'undefined' || propValue === null) {
+      return '' + propValue;
+    }
+    var propType = getPropType(propValue);
+    if (propType === 'object') {
+      if (propValue instanceof Date) {
+        return 'date';
+      } else if (propValue instanceof RegExp) {
+        return 'regexp';
+      }
+    }
+    return propType;
+  }
+
+  // Returns a string that is postfixed to a warning about an invalid type.
+  // For example, "undefined" or "of type array"
+  function getPostfixForTypeWarning(value) {
+    var type = getPreciseType(value);
+    switch (type) {
+      case 'array':
+      case 'object':
+        return 'an ' + type;
+      case 'boolean':
+      case 'date':
+      case 'regexp':
+        return 'a ' + type;
+      default:
+        return type;
+    }
+  }
+
+  // Returns class name of the object, if any.
+  function getClassName(propValue) {
+    if (!propValue.constructor || !propValue.constructor.name) {
+      return ANONYMOUS;
+    }
+    return propValue.constructor.name;
+  }
+
+  ReactPropTypes.checkPropTypes = checkPropTypes;
+  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+  ReactPropTypes.PropTypes = ReactPropTypes;
+
+  return ReactPropTypes;
+};
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+{
+  var ReactIs = reactIsExports;
+
+  // By explicitly using `prop-types` you are opting into new development behavior.
+  // http://fb.me/prop-types-in-prod
+  var throwOnDirectAccess = true;
+  propTypes.exports = factoryWithTypeCheckers(ReactIs.isElement, throwOnDirectAccess);
+}
+
+var propTypesExports = propTypes.exports;
+var PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);
+
+var react = {exports: {}};
+
+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.
+ */
+react_development.exports;
+
+(function (module, exports) {
+
+	{
+	  (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.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') {
+	    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));
+
+	      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
+
+
+	function getContextName(type) {
+	  return type.displayName || 'Context';
+	} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+	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;
+	          }
+	        }
+
+	      // eslint-disable-next-line no-fallthrough
+	    }
+	  }
+
+	  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 (getter && getter.isReactWarning) {
+	        return false;
+	      }
+	    }
+	  }
+
+	  return config.ref !== undefined;
+	}
+
+	function hasValidKey(config) {
+	  {
+	    if (hasOwnProperty.call(config, 'key')) {
+	      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+
+	      if (getter && getter.isReactWarning) {
+	        return false;
+	      }
+	    }
+	  }
+
+	  return config.key !== undefined;
+	}
+
+	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);
+	      }
+	    }
+	  };
+
+	  warnAboutAccessingKey.isReactWarning = true;
+	  Object.defineProperty(props, 'key', {
+	    get: warnAboutAccessingKey,
+	    configurable: true
+	  });
+	}
+
+	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);
+	      }
+	    }
+	  };
+
+	  warnAboutAccessingRef.isReactWarning = true;
+	  Object.defineProperty(props, 'ref', {
+	    get: warnAboutAccessingRef,
+	    configurable: true
+	  });
+	}
+
+	function warnIfStringRefCannotBeAutoConverted(config) {
+	  {
+	    if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
+	      var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+
+	      if (!didWarnAboutStringRefs[componentName]) {
+	        error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref);
+
+	        didWarnAboutStringRefs[componentName] = true;
+	      }
+	    }
+	  }
+	}
+	/**
+	 * 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;
+	};
+	/**
+	 * Create and return a new ReactElement of the given type.
+	 * See https://reactjs.org/docs/react-api.html#createelement
+	 */
+
+	function createElement(type, config, children) {
+	  var propName; // Reserved names are extracted
+
+	  var props = {};
+	  var key = null;
+	  var ref = null;
+	  var self = null;
+	  var source = null;
+
+	  if (config != null) {
+	    if (hasValidRef(config)) {
+	      ref = config.ref;
+
+	      {
+	        warnIfStringRefCannotBeAutoConverted(config);
+	      }
+	    }
+
+	    if (hasValidKey(config)) {
+	      {
+	        checkKeyStringCoercion(config.key);
+	      }
+
+	      key = '' + config.key;
+	    }
+
+	    self = config.__self === undefined ? null : config.__self;
+	    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+	    for (propName in config) {
+	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+	        props[propName] = config[propName];
+	      }
+	    }
+	  } // Children can be more than one argument, and those are transferred onto
+	  // the newly allocated props object.
+
+
+	  var childrenLength = arguments.length - 2;
+
+	  if (childrenLength === 1) {
+	    props.children = children;
+	  } else if (childrenLength > 1) {
+	    var childArray = Array(childrenLength);
+
+	    for (var i = 0; i < childrenLength; i++) {
+	      childArray[i] = arguments[i + 2];
+	    }
+
+	    {
+	      if (Object.freeze) {
+	        Object.freeze(childArray);
+	      }
+	    }
+
+	    props.children = childArray;
+	  } // Resolve default props
+
+
+	  if (type && type.defaultProps) {
+	    var defaultProps = type.defaultProps;
+
+	    for (propName in defaultProps) {
+	      if (props[propName] === undefined) {
+	        props[propName] = defaultProps[propName];
+	      }
+	    }
+	  }
+
+	  {
+	    if (key || ref) {
+	      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+
+	      if (key) {
+	        defineKeyPropWarningGetter(props, displayName);
+	      }
+
+	      if (ref) {
+	        defineRefPropWarningGetter(props, displayName);
+	      }
+	    }
+	  }
+
+	  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+	}
+	function cloneAndReplaceKey(oldElement, newKey) {
+	  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+	  return newElement;
+	}
+	/**
+	 * Clone and return a new ReactElement using element as the starting point.
+	 * See https://reactjs.org/docs/react-api.html#cloneelement
+	 */
+
+	function cloneElement(element, config, children) {
+	  if (element === null || element === undefined) {
+	    throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+	  }
+
+	  var propName; // Original props are copied
+
+	  var props = assign({}, element.props); // Reserved names are extracted
+
+	  var key = element.key;
+	  var ref = element.ref; // Self is preserved since the owner is preserved.
+
+	  var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+	  // transpiler, and the original source is probably a better indicator of the
+	  // true owner.
+
+	  var source = element._source; // Owner will be preserved, unless ref is overridden
+
+	  var owner = element._owner;
+
+	  if (config != null) {
+	    if (hasValidRef(config)) {
+	      // Silently steal the ref from the parent.
+	      ref = config.ref;
+	      owner = ReactCurrentOwner.current;
+	    }
+
+	    if (hasValidKey(config)) {
+	      {
+	        checkKeyStringCoercion(config.key);
+	      }
+
+	      key = '' + config.key;
+	    } // Remaining properties override existing props
+
+
+	    var defaultProps;
+
+	    if (element.type && element.type.defaultProps) {
+	      defaultProps = element.type.defaultProps;
+	    }
+
+	    for (propName in config) {
+	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+	        if (config[propName] === undefined && defaultProps !== undefined) {
+	          // Resolve default props
+	          props[propName] = defaultProps[propName];
+	        } else {
+	          props[propName] = config[propName];
+	        }
+	      }
+	    }
+	  } // Children can be more than one argument, and those are transferred onto
+	  // the newly allocated props object.
+
+
+	  var childrenLength = arguments.length - 2;
+
+	  if (childrenLength === 1) {
+	    props.children = children;
+	  } else if (childrenLength > 1) {
+	    var childArray = Array(childrenLength);
+
+	    for (var i = 0; i < childrenLength; i++) {
+	      childArray[i] = arguments[i + 2];
+	    }
+
+	    props.children = childArray;
+	  }
+
+	  return ReactElement(element.type, key, ref, self, source, owner, props);
+	}
+	/**
+	 * 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 SEPARATOR = '.';
+	var SUBSEPARATOR = ':';
+	/**
+	 * Escape and wrap key so it is safe to use as a reactid
+	 *
+	 * @param {string} key to be escaped.
+	 * @return {string} the escaped key.
+	 */
+
+	function escape(key) {
+	  var escapeRegex = /[=:]/g;
+	  var escaperLookup = {
+	    '=': '=0',
+	    ':': '=2'
+	  };
+	  var escapedString = key.replace(escapeRegex, function (match) {
+	    return escaperLookup[match];
+	  });
+	  return '$' + escapedString;
+	}
+	/**
+	 * 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.
+	 * @param {number} index Index that is used if a manual key is not provided.
+	 * @return {string}
+	 */
+
+
+	function getElementKey(element, index) {
+	  // Do some typechecking here since we call this blindly. We want to ensure
+	  // that we don't block potential future ES APIs.
+	  if (typeof element === 'object' && element !== null && element.key != null) {
+	    // Explicit key
+	    {
+	      checkKeyStringCoercion(element.key);
+	    }
+
+	    return escape('' + element.key);
+	  } // Implicit key determined by the index in the set
+
+
+	  return index.toString(36);
+	}
+
+	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, // 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);
+	      }
+
+	      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) {
+	    return func.call(context, child, count++);
+	  });
+	  return result;
+	}
+	/**
+	 * Count the number of children that are typically specified as
+	 * `props.children`.
+	 *
+	 * See https://reactjs.org/docs/react-api.html#reactchildrencount
+	 *
+	 * @param {?*} children Children tree container.
+	 * @return {number} The number of children.
+	 */
+
+
+	function countChildren(children) {
+	  var n = 0;
+	  mapChildren(children, function () {
+	    n++; // Don't return anything
+	  });
+	  return n;
+	}
+
+	/**
+	 * Iterates through children that are typically specified as `props.children`.
+	 *
+	 * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+	 *
+	 * The provided forEachFunc(child, index) will be called for each
+	 * leaf child.
+	 *
+	 * @param {?*} children Children tree container.
+	 * @param {function(*, int)} forEachFunc
+	 * @param {*} forEachContext Context for forEachContext.
+	 */
+	function forEachChildren(children, forEachFunc, forEachContext) {
+	  mapChildren(children, function () {
+	    forEachFunc.apply(this, arguments); // Don't return anything.
+	  }, forEachContext);
+	}
+	/**
+	 * Flatten a children object (typically specified as `props.children`) and
+	 * return an array with appropriately re-keyed children.
+	 *
+	 * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+	 */
+
+
+	function toArray(children) {
+	  return mapChildren(children, function (child) {
+	    return child;
+	  }) || [];
+	}
+	/**
+	 * Returns the first child in a collection of children and verifies that there
+	 * is only one child in the collection.
+	 *
+	 * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+	 *
+	 * The current implementation of this function assumes that a single child gets
+	 * passed without a wrapper, but the purpose of this helper function is to
+	 * abstract away the particular structure of children.
+	 *
+	 * @param {?object} children Child collection structure.
+	 * @return {ReactElement} The first and only `ReactElement` contained in the
+	 * structure.
+	 */
+
+
+	function onlyChild(children) {
+	  if (!isValidElement(children)) {
+	    throw new Error('React.Children.only expected to receive a single React element child.');
+	  }
+
+	  return children;
+	}
+
+	function createContext(defaultValue) {
+	  // TODO: Second argument used to be an optional `calculateChangedBits`
+	  // function. Warn to reserve for future use?
+	  var context = {
+	    $$typeof: REACT_CONTEXT_TYPE,
+	    // As a workaround to support multiple concurrent renderers, we categorize
+	    // some renderers as primary and others as secondary. We only expect
+	    // there to be two concurrent renderers at most: React Native (primary) and
+	    // Fabric (secondary); React DOM (primary) and React ART (secondary).
+	    // Secondary renderers store their context values on separate fields.
+	    _currentValue: defaultValue,
+	    _currentValue2: defaultValue,
+	    // Used to track how many concurrent renderers this context currently
+	    // supports within in a single renderer. Such as parallel server rendering.
+	    _threadCount: 0,
+	    // These are circular
+	    Provider: null,
+	    Consumer: null,
+	    // Add these to use same hidden class in VM as ServerContext
+	    _defaultValue: null,
+	    _globalName: null
+	  };
+	  context.Provider = {
+	    $$typeof: REACT_PROVIDER_TYPE,
+	    _context: context
+	  };
+	  var hasWarnedAboutUsingNestedContextConsumers = false;
+	  var hasWarnedAboutUsingConsumerProvider = false;
+	  var hasWarnedAboutDisplayNameOnConsumer = false;
+
+	  {
+	    // A separate object, but proxies back to the original context object for
+	    // backwards compatibility. It has a different $$typeof, so we can properly
+	    // warn for the incorrect usage of Context as a Consumer.
+	    var Consumer = {
+	      $$typeof: REACT_CONTEXT_TYPE,
+	      _context: context
+	    }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
+
+	    Object.defineProperties(Consumer, {
+	      Provider: {
+	        get: function () {
+	          if (!hasWarnedAboutUsingConsumerProvider) {
+	            hasWarnedAboutUsingConsumerProvider = true;
+
+	            error('Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?');
+	          }
+
+	          return context.Provider;
+	        },
+	        set: function (_Provider) {
+	          context.Provider = _Provider;
+	        }
+	      },
+	      _currentValue: {
+	        get: function () {
+	          return context._currentValue;
+	        },
+	        set: function (_currentValue) {
+	          context._currentValue = _currentValue;
+	        }
+	      },
+	      _currentValue2: {
+	        get: function () {
+	          return context._currentValue2;
+	        },
+	        set: function (_currentValue2) {
+	          context._currentValue2 = _currentValue2;
+	        }
+	      },
+	      _threadCount: {
+	        get: function () {
+	          return context._threadCount;
+	        },
+	        set: function (_threadCount) {
+	          context._threadCount = _threadCount;
+	        }
+	      },
+	      Consumer: {
+	        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?');
+	          }
+
+	          return context.Consumer;
+	        }
+	      },
+	      displayName: {
+	        get: function () {
+	          return context.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);
+
+	            hasWarnedAboutDisplayNameOnConsumer = true;
+	          }
+	        }
+	      }
+	    }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
+
+	    context.Consumer = Consumer;
+	  }
+
+	  {
+	    context._currentRenderer = null;
+	    context._currentRenderer2 = null;
+	  }
+
+	  return context;
+	}
+
+	var 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.
+	    // This might throw either because it's missing or throws. If so, we treat it
+	    // as still uninitialized and try again next time. Which is the same as what
+	    // happens if the ctor or any wrappers processing the ctor throws. This might
+	    // end up fixing it if the resolution was a concurrency bug.
+
+	    thenable.then(function (moduleObject) {
+	      if (payload._status === Pending || payload._status === Uninitialized) {
+	        // Transition to the next state.
+	        var resolved = payload;
+	        resolved._status = Resolved;
+	        resolved._result = moduleObject;
+	      }
+	    }, function (error) {
+	      if (payload._status === Pending || payload._status === Uninitialized) {
+	        // Transition to the next state.
+	        var rejected = payload;
+	        rejected._status = Rejected;
+	        rejected._result = error;
+	      }
+	    });
+
+	    if (payload._status === Uninitialized) {
+	      // In case, we're still uninitialized, then we're waiting for the thenable
+	      // to resolve. Set it as pending in the meantime.
+	      var pending = payload;
+	      pending._status = Pending;
+	      pending._result = thenable;
+	    }
+	  }
+
+	  if (payload._status === Resolved) {
+	    var moduleObject = payload._result;
+
+	    {
+	      if (moduleObject === undefined) {
+	        error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
+	        'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject);
+	      }
+	    }
+
+	    {
+	      if (!('default' in moduleObject)) {
+	        error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
+	        'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject);
+	      }
+	    }
+
+	    return moduleObject.default;
+	  } else {
+	    throw payload._result;
+	  }
+	}
+
+	function lazy(ctor) {
+	  var payload = {
+	    // We use these fields to store the result.
+	    _status: Uninitialized,
+	    _result: ctor
+	  };
+	  var lazyType = {
+	    $$typeof: REACT_LAZY_TYPE,
+	    _payload: payload,
+	    _init: lazyInitializer
+	  };
+
+	  {
+	    // In production, this would just set it on the object.
+	    var defaultProps;
+	    var propTypes; // $FlowFixMe
+
+	    Object.defineProperties(lazyType, {
+	      defaultProps: {
+	        configurable: true,
+	        get: function () {
+	          return defaultProps;
+	        },
+	        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', {
+	            enumerable: true
+	          });
+	        }
+	      },
+	      propTypes: {
+	        configurable: true,
+	        get: function () {
+	          return propTypes;
+	        },
+	        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', {
+	            enumerable: true
+	          });
+	        }
+	      }
+	    });
+	  }
+
+	  return lazyType;
+	}
+
+	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);
+	    } else {
+	      if (render.length !== 0 && render.length !== 2) {
+	        error('forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.');
+	      }
+	    }
+
+	    if (render != null) {
+	      if (render.defaultProps != null || render.propTypes != null) {
+	        error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?');
+	      }
+	    }
+	  }
+
+	  var elementType = {
+	    $$typeof: REACT_FORWARD_REF_TYPE,
+	    render: render
+	  };
+
+	  {
+	    var ownName;
+	    Object.defineProperty(elementType, 'displayName', {
+	      enumerable: false,
+	      configurable: true,
+	      get: function () {
+	        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) {
+	          render.displayName = name;
+	        }
+	      }
+	    });
+	  }
+
+	  return elementType;
+	}
+
+	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 (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+	    // types supported by any Flight configuration anywhere since
+	    // we don't know which Flight build this will end up being used
+	    // with.
+	    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+	      return true;
+	    }
+	  }
+
+	  return false;
+	}
+
+	function memo(type, compare) {
+	  {
+	    if (!isValidElementType(type)) {
+	      error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
+	    }
+	  }
+
+	  var elementType = {
+	    $$typeof: REACT_MEMO_TYPE,
+	    type: type,
+	    compare: compare === undefined ? null : compare
+	  };
+
+	  {
+	    var ownName;
+	    Object.defineProperty(elementType, 'displayName', {
+	      enumerable: false,
+	      configurable: true,
+	      get: function () {
+	        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) {
+	          type.displayName = name;
+	        }
+	      }
+	    });
+	  }
+
+	  return elementType;
+	}
+
+	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.');
+	    }
+	  } // 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) {
+	  var dispatcher = resolveDispatcher();
+
+	  {
+	    // TODO: add a more generic warning for invalid values.
+	    if (Context._context !== undefined) {
+	      var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
+	      // and nobody should be using this in existing code.
+
+	      if (realContext.Consumer === Context) {
+	        error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
+	      } else if (realContext.Provider === Context) {
+	        error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
+	      }
+	    }
+	  }
+
+	  return dispatcher.useContext(Context);
+	}
+	function useState(initialState) {
+	  var dispatcher = resolveDispatcher();
+	  return dispatcher.useState(initialState);
+	}
+	function useReducer(reducer, initialArg, init) {
+	  var dispatcher = resolveDispatcher();
+	  return dispatcher.useReducer(reducer, initialArg, init);
+	}
+	function useRef(initialValue) {
+	  var dispatcher = resolveDispatcher();
+	  return dispatcher.useRef(initialValue);
+	}
+	function useEffect(create, deps) {
+	  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);
+	}
+	function useCallback(callback, deps) {
+	  var dispatcher = resolveDispatcher();
+	  return dispatcher.useCallback(callback, deps);
+	}
+	function useMemo(create, deps) {
+	  var dispatcher = resolveDispatcher();
+	  return dispatcher.useMemo(create, deps);
+	}
+	function useImperativeHandle(ref, create, deps) {
+	  var dispatcher = resolveDispatcher();
+	  return dispatcher.useImperativeHandle(ref, create, deps);
+	}
+	function useDebugValue(value, formatterFn) {
+	  {
+	    var dispatcher = resolveDispatcher();
+	    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
+	// 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;
+	      prevInfo = console.info;
+	      prevWarn = console.warn;
+	      prevError = console.error;
+	      prevGroup = console.group;
+	      prevGroupCollapsed = console.groupCollapsed;
+	      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+	      var props = {
+	        configurable: true,
+	        enumerable: true,
+	        value: disabledLog,
+	        writable: true
+	      }; // $FlowFixMe Flow thinks console is immutable.
+
+	      Object.defineProperties(console, {
+	        info: props,
+	        log: props,
+	        warn: props,
+	        error: props,
+	        group: props,
+	        groupCollapsed: props,
+	        groupEnd: props
+	      });
+	      /* eslint-enable react-internal/no-production-logging */
+	    }
+
+	    disabledDepth++;
+	  }
+	}
+	function reenableLogs() {
+	  {
+	    disabledDepth--;
+
+	    if (disabledDepth === 0) {
+	      /* eslint-disable react-internal/no-production-logging */
+	      var props = {
+	        configurable: true,
+	        enumerable: true,
+	        writable: true
+	      }; // $FlowFixMe Flow thinks console is immutable.
+
+	      Object.defineProperties(console, {
+	        log: assign({}, props, {
+	          value: prevLog
+	        }),
+	        info: assign({}, props, {
+	          value: prevInfo
+	        }),
+	        warn: assign({}, props, {
+	          value: prevWarn
+	        }),
+	        error: assign({}, props, {
+	          value: prevError
+	        }),
+	        group: assign({}, props, {
+	          value: prevGroup
+	        }),
+	        groupCollapsed: assign({}, props, {
+	          value: prevGroupCollapsed
+	        }),
+	        groupEnd: assign({}, props, {
+	          value: prevGroupEnd
+	        })
+	      });
+	      /* eslint-enable react-internal/no-production-logging */
+	    }
+
+	    if (disabledDepth < 0) {
+	      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+	    }
+	  }
+	}
+
+	var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+	var prefix;
+	function describeBuiltInComponentFrame(name, source, ownerFn) {
+	  {
+	    if (prefix === undefined) {
+	      // Extract the VM specific prefix used by each line.
+	      try {
+	        throw Error();
+	      } catch (x) {
+	        var match = x.stack.trim().match(/\n( *(at )?)/);
+	        prefix = match && match[1] || '';
+	      }
+	    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+	    return '\n' + prefix + name;
+	  }
+	}
+	var 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 '';
+	  }
+
+	  {
+	    var frame = componentFrameCache.get(fn);
+
+	    if (frame !== undefined) {
+	      return frame;
+	    }
+	  }
+
+	  var control;
+	  reentry = true;
+	  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
+
+	  Error.prepareStackTrace = undefined;
+	  var previousDispatcher;
+
+	  {
+	    previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
+	    // for warnings.
+
+	    ReactCurrentDispatcher$1.current = null;
+	    disableLogs();
+	  }
+
+	  try {
+	    // This should throw.
+	    if (construct) {
+	      // Something should be setting the props in the constructor.
+	      var Fake = function () {
+	        throw Error();
+	      }; // $FlowFixMe
+
+
+	      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) {
+	        // We construct a different control for this case to include any extra
+	        // frames added by the construct call.
+	        try {
+	          Reflect.construct(Fake, []);
+	        } catch (x) {
+	          control = x;
+	        }
+
+	        Reflect.construct(fn, [], Fake);
+	      } else {
+	        try {
+	          Fake.call();
+	        } catch (x) {
+	          control = x;
+	        }
+
+	        fn.call(Fake.prototype);
+	      }
+	    } else {
+	      try {
+	        throw Error();
+	      } 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') {
+	      // This extracts the first frame from the sample that isn't also in the control.
+	      // Skipping one frame that we assume is the frame that calls the two.
+	      var sampleLines = sample.stack.split('\n');
+	      var controlLines = control.stack.split('\n');
+	      var s = sampleLines.length - 1;
+	      var c = controlLines.length - 1;
+
+	      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+	        // We expect at least one stack frame to be shared.
+	        // Typically this will be the root most one. However, stack frames may be
+	        // cut off due to maximum stack limits. In this case, one maybe cut off
+	        // earlier than the other. We assume that the sample is longer or the same
+	        // and there for cut off earlier. So we should find the root most frame in
+	        // the sample somewhere in the control.
+	        c--;
+	      }
+
+	      for (; s >= 1 && c >= 0; s--, c--) {
+	        // Next we find the first one that isn't the same which should be the
+	        // frame that called our sample function and the control.
+	        if (sampleLines[s] !== controlLines[c]) {
+	          // In V8, the first line is describing the message but other VMs don't.
+	          // If we're about to return the first line, and the control is also on the same
+	          // line, that's a pretty good indicator that our sample threw at same line as
+	          // the control. I.e. before we entered the sample frame. So we ignore this result.
+	          // This can happen if you passed a class to function component, or non-function.
+	          if (s !== 1 || c !== 1) {
+	            do {
+	              s--;
+	              c--; // We may still have similar intermediate frames from the construct call.
+	              // The next one that isn't the same should be our match though.
+
+	              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+	                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+	                var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+	                // but we have a user-provided "displayName"
+	                // splice it in to make the stack more readable.
+
+
+	                if (fn.displayName && _frame.includes('<anonymous>')) {
+	                  _frame = _frame.replace('<anonymous>', fn.displayName);
+	                }
+
+	                {
+	                  if (typeof fn === 'function') {
+	                    componentFrameCache.set(fn, _frame);
+	                  }
+	                } // Return the line we found.
+
+
+	                return _frame;
+	              }
+	            } while (s >= 1 && c >= 0);
+	          }
+
+	          break;
+	        }
+	      }
+	    }
+	  } finally {
+	    reentry = false;
+
+	    {
+	      ReactCurrentDispatcher$1.current = previousDispatcher;
+	      reenableLogs();
+	    }
+
+	    Error.prepareStackTrace = previousPrepareStackTrace;
+	  } // Fallback to just using the name if we couldn't make it throw.
+
+
+	  var name = fn ? fn.displayName || fn.name : '';
+	  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+	  {
+	    if (typeof fn === 'function') {
+	      componentFrameCache.set(fn, syntheticFrame);
+	    }
+	  }
+
+	  return syntheticFrame;
+	}
+	function describeFunctionComponentFrame(fn, source, ownerFn) {
+	  {
+	    return describeNativeComponentFrame(fn, false);
+	  }
+	}
+
+	function shouldConstruct(Component) {
+	  var prototype = Component.prototype;
+	  return !!(prototype && prototype.isReactComponent);
+	}
+
+	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;
+	      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+	      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+	    } else {
+	      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+	    }
+	  }
+	}
+
+	function checkPropTypes(typeSpecs, values, location, componentName, element) {
+	  {
+	    // $FlowFixMe This is okay but Flow doesn't know it.
+	    var has = Function.call.bind(hasOwnProperty);
+
+	    for (var typeSpecName in typeSpecs) {
+	      if (has(typeSpecs, typeSpecName)) {
+	        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            // eslint-disable-next-line react-internal/prod-error-codes
+	            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+
+	          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
+	        } catch (ex) {
+	          error$1 = ex;
+	        }
+
+	        if (error$1 && !(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);
+
+	          setCurrentlyValidatingElement(null);
+	        }
+
+	        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);
+
+	          setCurrentlyValidatingElement(null);
+	        }
+	      }
+	    }
+	  }
+	}
+
+	function setCurrentlyValidatingElement$1(element) {
+	  {
+	    if (element) {
+	      var owner = element._owner;
+	      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+	      setExtraStackFrame(stack);
+	    } else {
+	      setExtraStackFrame(null);
+	    }
+	  }
+	}
+
+	var 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 '';
+	}
+
+	function getSourceInfoErrorAddendum(source) {
+	  if (source !== undefined) {
+	    var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+	    var lineNumber = source.lineNumber;
+	    return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
+	  }
+
+	  return '';
+	}
+
+	function getSourceInfoErrorAddendumForProps(elementProps) {
+	  if (elementProps !== null && elementProps !== undefined) {
+	    return getSourceInfoErrorAddendum(elementProps.__source);
+	  }
+
+	  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;
+
+	    if (parentName) {
+	      info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+	    }
+	  }
+
+	  return info;
+	}
+	/**
+	 * Warn if the element doesn't have an explicit key assigned to it.
+	 * This element is in an array. The array could grow and shrink or be
+	 * reordered. All children that haven't already been validated are required to
+	 * have a "key" property assigned to it. Error statuses are cached so a warning
+	 * will only be shown once.
+	 *
+	 * @internal
+	 * @param {ReactElement} element Element that requires a key.
+	 * @param {*} parentType element's parent's type.
+	 */
+
+
+	function validateExplicitKey(element, parentType) {
+	  if (!element._store || element._store.validated || element.key != null) {
+	    return;
+	  }
+
+	  element._store.validated = true;
+	  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+
+	  if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+	    return;
+	  }
+
+	  ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+	  // property, it may be the creator of the child that's responsible for
+	  // assigning it a key.
+
+	  var childOwner = '';
+
+	  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+	    // Give the component that originally created this child.
+	    childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+	  }
+
+	  {
+	    setCurrentlyValidatingElement$1(element);
+
+	    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
+
+	    setCurrentlyValidatingElement$1(null);
+	  }
+	}
+	/**
+	 * Ensure that every element either is passed in a static location, in an
+	 * array with an explicit keys property defined, or in an object literal
+	 * with valid key property.
+	 *
+	 * @internal
+	 * @param {ReactNode} node Statically passed child of any type.
+	 * @param {*} parentType node's parent's type.
+	 */
+
+
+	function validateChildKeys(node, parentType) {
+	  if (typeof node !== 'object') {
+	    return;
+	  }
+
+	  if (isArray(node)) {
+	    for (var i = 0; i < node.length; i++) {
+	      var child = node[i];
+
+	      if (isValidElement(child)) {
+	        validateExplicitKey(child, parentType);
+	      }
+	    }
+	  } else if (isValidElement(node)) {
+	    // This element was passed in a valid location.
+	    if (node._store) {
+	      node._store.validated = true;
+	    }
+	  } else if (node) {
+	    var iteratorFn = getIteratorFn(node);
+
+	    if (typeof iteratorFn === 'function') {
+	      // Entry iterators used to provide implicit keys,
+	      // but now we print a separate warning for them later.
+	      if (iteratorFn !== node.entries) {
+	        var iterator = iteratorFn.call(node);
+	        var step;
+
+	        while (!(step = iterator.next()).done) {
+	          if (isValidElement(step.value)) {
+	            validateExplicitKey(step.value, parentType);
+	          }
+	        }
+	      }
+	    }
+	  }
+	}
+	/**
+	 * Given an element, validate that its props follow the propTypes definition,
+	 * provided by the type.
+	 *
+	 * @param {ReactElement} element
+	 */
+
+
+	function validatePropTypes(element) {
+	  {
+	    var type = element.type;
+
+	    if (type === null || type === undefined || typeof type === 'string') {
+	      return;
+	    }
+
+	    var propTypes;
+
+	    if (typeof type === 'function') {
+	      propTypes = type.propTypes;
+	    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+	    // Inner props are checked in the reconciler.
+	    type.$$typeof === REACT_MEMO_TYPE)) {
+	      propTypes = type.propTypes;
+	    } else {
+	      return;
+	    }
+
+	    if (propTypes) {
+	      // Intentionally inside to avoid triggering lazy initializers:
+	      var name = getComponentNameFromType(type);
+	      checkPropTypes(propTypes, element.props, 'prop', name, element);
+	    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+	      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
+
+	      var _name = getComponentNameFromType(type);
+
+	      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
+	    }
+
+	    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
+	      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
+	    }
+	  }
+	}
+	/**
+	 * Given a fragment, validate that it can only be provided with fragment props
+	 * @param {ReactElement} fragment
+	 */
+
+
+	function validateFragmentProps(fragment) {
+	  {
+	    var keys = Object.keys(fragment.props);
+
+	    for (var i = 0; i < keys.length; i++) {
+	      var key = keys[i];
+
+	      if (key !== 'children' && key !== 'key') {
+	        setCurrentlyValidatingElement$1(fragment);
+
+	        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+
+	        setCurrentlyValidatingElement$1(null);
+	        break;
+	      }
+	    }
+
+	    if (fragment.ref !== null) {
+	      setCurrentlyValidatingElement$1(fragment);
+
+	      error('Invalid attribute `ref` supplied to `React.Fragment`.');
+
+	      setCurrentlyValidatingElement$1(null);
+	    }
+	  }
+	}
+	function createElementWithValidation(type, props, children) {
+	  var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+	  // succeed and there will likely be errors in render.
+
+	  if (!validType) {
+	    var info = '';
+
+	    if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+	      info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
+	    }
+
+	    var sourceInfo = getSourceInfoErrorAddendumForProps(props);
+
+	    if (sourceInfo) {
+	      info += sourceInfo;
+	    } else {
+	      info += getDeclarationErrorAddendum();
+	    }
+
+	    var typeString;
+
+	    if (type === null) {
+	      typeString = 'null';
+	    } else if (isArray(type)) {
+	      typeString = 'array';
+	    } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+	      typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+	      info = ' Did you accidentally export a JSX literal instead of a component?';
+	    } else {
+	      typeString = typeof type;
+	    }
+
+	    {
+	      error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+	    }
+	  }
+
+	  var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
+	  // TODO: Drop this when these are no longer allowed as the type argument.
+
+	  if (element == null) {
+	    return element;
+	  } // Skip key warning if the type isn't valid since our key validation logic
+	  // doesn't expect a non-string/function type and can throw confusing errors.
+	  // We don't want exception behavior to differ between dev and prod.
+	  // (Rendering will throw with a helpful message and as soon as the type is
+	  // fixed, the key warnings will appear.)
+
+
+	  if (validType) {
+	    for (var i = 2; i < arguments.length; i++) {
+	      validateChildKeys(arguments[i], type);
+	    }
+	  }
+
+	  if (type === REACT_FRAGMENT_TYPE) {
+	    validateFragmentProps(element);
+	  } else {
+	    validatePropTypes(element);
+	  }
+
+	  return element;
+	}
+	var 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.');
+	    } // Legacy hook: remove it
+
+
+	    Object.defineProperty(validatedFactory, 'type', {
+	      enumerable: false,
+	      get: function () {
+	        warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+
+	        Object.defineProperty(this, 'type', {
+	          value: type
+	        });
+	        return type;
+	      }
+	    });
+	  }
+
+	  return validatedFactory;
+	}
+	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;
+	}
+
+	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;
+	      }
+	    }
+	  }
+	}
+
+	var createElement$1 =  createElementWithValidation ;
+	var cloneElement$1 =  cloneElementWithValidation ;
+	var createFactory =  createFactoryWithValidation ;
+	var Children = {
+	  map: mapChildren,
+	  forEach: forEachChildren,
+	  count: countChildren,
+	  toArray: toArray,
+	  only: onlyChild
+	};
+
+	exports.Children = Children;
+	exports.Component = Component;
+	exports.Fragment = REACT_FRAGMENT_TYPE;
+	exports.Profiler = REACT_PROFILER_TYPE;
+	exports.PureComponent = PureComponent;
+	exports.StrictMode = REACT_STRICT_MODE_TYPE;
+	exports.Suspense = REACT_SUSPENSE_TYPE;
+	exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+	exports.cloneElement = cloneElement$1;
+	exports.createContext = createContext;
+	exports.createElement = createElement$1;
+	exports.createFactory = createFactory;
+	exports.createRef = createRef;
+	exports.forwardRef = forwardRef;
+	exports.isValidElement = isValidElement;
+	exports.lazy = lazy;
+	exports.memo = memo;
+	exports.startTransition = startTransition;
+	exports.unstable_act = act;
+	exports.useCallback = useCallback;
+	exports.useContext = useContext;
+	exports.useDebugValue = useDebugValue;
+	exports.useDeferredValue = useDeferredValue;
+	exports.useEffect = useEffect;
+	exports.useId = useId;
+	exports.useImperativeHandle = useImperativeHandle;
+	exports.useInsertionEffect = useInsertionEffect;
+	exports.useLayoutEffect = useLayoutEffect;
+	exports.useMemo = useMemo;
+	exports.useReducer = useReducer;
+	exports.useRef = useRef;
+	exports.useState = useState;
+	exports.useSyncExternalStore = useSyncExternalStore;
+	exports.useTransition = useTransition;
+	exports.version = ReactVersion;
+	          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+	}
+	        
+	  })();
+	} 
+} (react_development, react_development.exports));
+
+var react_developmentExports = react_development.exports;
+
+{
+  react.exports = react_developmentExports;
+}
+
+var reactExports = react.exports;
+var React = /*@__PURE__*/getDefaultExportFromCjs(reactExports);
+
+function styleInject(css, ref) {
+  if ( ref === void 0 ) ref = {};
+  var insertAt = ref.insertAt;
+
+  if (!css || typeof document === 'undefined') { return; }
+
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+var css_248z = ":root {\n  --rpf-brand-black: hsla(60, 4%, 11%, 1);\n  --rpf-brand-leaf: hsla(123, 43%, 48%, 1);\n  --rpf-brand-raspberry: hsla(342, 71%, 47%, 1);\n}\n\n:root {\n  --rpf-red-100: hsla(4, 89%, 96%, 1);\n  --rpf-red-200: hsla(1, 87%, 91%, 1);\n  --rpf-red-400: hsla(1, 87%, 82%, 1);\n  --rpf-red-600: hsla(1, 87%, 72%, 1);\n  --rpf-red-800: hsla(1, 87%, 63%, 1);\n  --rpf-red-900: hsla(1, 52%, 50%, 1);\n  --rpf-green-100: hsla(125, 41%, 95%, 1);\n  --rpf-green-200: hsla(122, 39%, 87%, 1);\n  --rpf-green-400: hsla(123, 40%, 74%, 1);\n  --rpf-green-600: hsla(123, 40%, 61%, 1);\n  --rpf-green-800: hsla(123, 43%, 48%, 1);\n  --rpf-green-900: hsla(123, 43%, 36%, 1);\n  --rpf-teal-100: hsla(176, 55%, 94%, 1);\n  --rpf-teal-200: hsla(174, 55%, 85%, 1);\n  --rpf-teal-400: hsla(174, 55%, 70%, 1);\n  --rpf-teal-600: hsla(174, 56%, 56%, 1);\n  --rpf-teal-800: hsla(174, 81%, 41%, 1);\n  --rpf-teal-900: hsla(174, 81%, 29%, 1);\n  --rpf-orange-100: hsla(31, 100%, 95%, 1);\n  --rpf-orange-200: hsla(32, 100%, 88%, 1);\n  --rpf-orange-400: hsla(31, 100%, 77%, 1);\n  --rpf-orange-600: hsla(31, 99%, 65%, 1);\n  --rpf-orange-800: hsla(31, 99%, 54%, 1);\n  --rpf-orange-900: hsla(31, 85%, 37%, 1);\n  --rpf-yellow-100: hsla(51, 100%, 95%, 1);\n  --rpf-yellow-200: hsla(52, 100%, 87%, 1);\n  --rpf-yellow-400: hsla(51, 100%, 75%, 1);\n  --rpf-yellow-600: hsla(52, 100%, 63%, 1);\n  --rpf-yellow-800: hsla(52, 100%, 50%, 1);\n  --rpf-yellow-900: hsla(52, 100%, 26%, 1);\n  --rpf-purple-100: hsla(282, 36%, 95%, 1);\n  --rpf-purple-200: hsla(279, 38%, 87%, 1);\n  --rpf-purple-400: hsla(279, 38%, 73%, 1);\n  --rpf-purple-600: hsla(279, 37%, 60%, 1);\n  --rpf-purple-800: hsla(279, 43%, 47%, 1);\n  --rpf-purple-900: hsla(280, 43%, 37%, 1);\n  --rpf-navy-100: hsla(235, 38%, 94%, 1);\n  --rpf-navy-200: hsla(234, 38%, 84%, 1);\n  --rpf-navy-400: hsla(235, 38%, 69%, 1);\n  --rpf-navy-600: hsla(235, 38%, 53%, 1);\n  --rpf-navy-800: hsla(235, 63%, 37%, 1);\n  --rpf-navy-900: hsla(234, 63%, 30%, 1);\n  --rpf-blue-100: hsla(203, 86%, 95%, 1);\n  --rpf-blue-200: hsla(204, 88%, 87%, 1);\n  --rpf-blue-400: hsla(204, 88%, 74%, 1);\n  --rpf-blue-600: hsla(204, 89%, 60%, 1);\n  --rpf-blue-800: hsla(204, 100%, 47%, 1);\n  --rpf-blue-900: hsla(204, 100%, 38%, 1);\n}\n\n:root {\n  --rpf-white: hsla(0, 0%, 100%, 1);\n  --rpf-off-white: hsla(225, 25%, 97%, 1);\n  --rpf-grey-50: hsla(210, 8%, 95%, 1);\n  --rpf-grey-100: hsla(228, 10%, 90%, 1);\n  --rpf-grey-150: hsla(223, 9%, 85%, 1);\n  --rpf-grey-200: hsla(228, 10%, 80%, 1);\n  --rpf-grey-300: hsla(229, 9%, 75%, 1);\n  --rpf-grey-400: hsla(229, 8%, 61%, 1);\n  --rpf-grey-500: hsla(229, 9%, 42%, 1);\n  --rpf-grey-600: hsla(228, 9%, 32%, 1);\n  --rpf-grey-700: hsla(228, 9%, 22%, 1);\n  --rpf-grey-800: hsla(232, 9%, 18%, 1);\n  --rpf-grey-850: hsla(228, 9%, 15%, 1);\n  --rpf-grey-900: hsla(228, 9%, 10%, 1);\n  --rpf-grey-950: hsla(228, 8%, 5%, 1);\n  --rpf-black: hsla(0, 0%, 0%, 1);\n}\n\n:root {\n  --font-size-0-5: 0.5rem;\n  --font-size-0-75: 0.75rem;\n  --font-size-1: 1rem;\n  --font-size-1-5: 1.25rem;\n  --font-size-2: 1.5rem;\n  --font-size-3: 2rem;\n  --font-size-4: 2.5rem;\n  --font-size-5: 3rem;\n  --font-size-6: 3.5rem;\n  --font-size-7: 4rem;\n  --font-size-8: 4.5rem;\n  --font-size-9: 5rem;\n}\n\n:root {\n  --font-weight-regular: 400;\n  --font-weight-bold: 700;\n}\n\n:root {\n  --border-radius: var(--space-1);\n  --input-border-width: 2px;\n  --alert-border-width: 2px;\n}\n\n:root {\n  --space-0-125: 0.0625rem;\n  --space-0-25: 0.125rem;\n  --space-0-5: 0.25rem;\n  --space-1: 0.5rem;\n  --space-1-5: 0.75rem;\n  --space-2: 1rem;\n  --space-3: 1.5rem;\n  --space-4: 2rem;\n  --space-5: 2.5rem;\n  --space-6: 3rem;\n  --space-7: 3.5rem;\n  --space-8: 4rem;\n  --space-9: 4.5rem;\n  --space-10: 5rem;\n}\n\n:root {\n  --rpf-button-primary-background-color: var(--rpf-navy-800);\n  --rpf-button-primary-background-color-hover: var(--rpf-navy-900);\n  --rpf-button-primary-background-color-active: var(--rpf-navy-600);\n  --rpf-button-primary-background-color-disabled: var(--rpf-grey-600);\n  --rpf-button-primary-text-color: var(--rpf-white);\n  --rpf-button-border-radius: var(--border-radius);\n  --rpf-button-lg-height: 48px;\n  --rpf-button-sm-height: 32px;\n  /* 44px min-height to meet WCAG AAA target size requirements */\n  --rpf-button-min-target-size: 44px;\n}\n\n.rpf-button {\n  all: unset;\n  align-items: center;\n  color: var(--rpf-button-primary-text-color);\n  /*\n   * We've decided to follow the masses on this and have a pointer on buttons.\n   * Google, Facebook, Twitter, Mozilla, and Microsoft amongst many others have a pointer on buttons.\n   */\n  cursor: pointer;\n  display: flex;\n  font-size: var(--font-size-1-5);\n  font-weight: var(--font-weight-bold);\n  gap: var(--space-1);\n  min-height: calc(var(--rpf-button-lg-height) - var(--space-1) - var(--space-1));\n  padding: var(--space-1) var(--space-2);\n  position: relative;\n  text-align: center;\n  text-decoration: none;\n  /* Fixes a rendering error that sometimes occurs due to negative z-index */\n  transform: scale(1);\n  width: fit-content;\n  /* A bit of a hack to allow for separate visual and target heights */\n}\n.rpf-button::before {\n  background-color: var(--rpf-button-primary-background-color);\n  border-color: var(--rpf-button-primary-background-color);\n  border-radius: var(--rpf-button-border-radius);\n  border-style: solid;\n  border-width: 2px;\n  content: \"\";\n  display: block;\n  inset: 0;\n  position: absolute;\n  /* To ensure it renders under its siblings */\n  z-index: -1;\n}\n.rpf-button:hover::before {\n  background-color: var(--rpf-button-primary-background-color-hover);\n  border-color: var(--rpf-button-primary-background-color-hover);\n}\n.rpf-button:active::before {\n  background-color: var(--rpf-button-primary-background-color-active);\n  border-color: var(--rpf-button-primary-background-color-active);\n}\n.rpf-button:focus-visible::before {\n  outline: 3px solid var(--rpf-brand-raspberry);\n}\n.rpf-button:disabled, .rpf-button--disabled {\n  cursor: default;\n}\n.rpf-button:disabled:hover::before, .rpf-button:disabled::before, .rpf-button--disabled:hover::before, .rpf-button--disabled::before {\n  border-color: var(--rpf-button-primary-background-color-disabled);\n  background-color: var(--rpf-button-primary-background-color-disabled);\n}\n.rpf-button--secondary {\n  color: var(--rpf-button-primary-background-color);\n}\n.rpf-button--secondary::before {\n  background-color: var(--rpf-button-primary-text-color);\n}\n.rpf-button--secondary:hover {\n  color: var(--rpf-button-primary-background-color-hover);\n}\n.rpf-button--secondary:hover::before {\n  background-color: var(--rpf-button-primary-text-color);\n  border-color: var(--rpf-button-primary-background-color-hover);\n}\n.rpf-button--secondary:active {\n  color: var(--rpf-button-primary-background-color-active);\n}\n.rpf-button--secondary:active::before {\n  background-color: var(--rpf-button-primary-text-color);\n  border-color: var(--rpf-button-primary-background-color-active);\n}\n.rpf-button--secondary:disabled, .rpf-button--secondary.rpf-button--disabled {\n  color: var(--rpf-button-primary-background-color-disabled);\n}\n.rpf-button--secondary:disabled:hover::before, .rpf-button--secondary:disabled:before, .rpf-button--secondary.rpf-button--disabled:hover::before, .rpf-button--secondary.rpf-button--disabled:before {\n  background-color: var(--rpf-button-primary-text-color);\n  border-color: var(--rpf-button-primary-background-color-disabled);\n}\n.rpf-button--tertiary {\n  color: var(--rpf-button-primary-background-color);\n}\n.rpf-button--tertiary::before {\n  background-color: transparent;\n  border-color: transparent;\n}\n.rpf-button--tertiary:hover {\n  color: var(--rpf-button-primary-background-color-hover);\n}\n.rpf-button--tertiary:hover::before {\n  background-color: transparent;\n  border-color: transparent;\n}\n.rpf-button--tertiary:active {\n  color: var(--rpf-button-primary-background-color-active);\n}\n.rpf-button--tertiary:active::before {\n  background-color: transparent;\n}\n.rpf-button--tertiary:disabled, .rpf-button--tertiary.rpf-button--disabled {\n  color: var(--rpf-button-primary-background-color-disabled);\n}\n.rpf-button--tertiary:disabled:hover::before, .rpf-button--tertiary:disabled::before, .rpf-button--tertiary.rpf-button--disabled:hover::before, .rpf-button--tertiary.rpf-button--disabled::before {\n  background-color: transparent;\n  border-color: transparent;\n}\n.rpf-button--icon-only {\n  height: var(--rpf-button-lg-height);\n  line-height: var(--rpf-button-lg-height);\n  padding: 0;\n  text-align: center;\n  width: var(--rpf-button-lg-height);\n}\n.rpf-button--icon-only .rpf-button__icon {\n  margin: 0 auto;\n}\n.rpf-button--sm {\n  font-size: var(--font-size-1);\n  min-height: calc(var(--rpf-button-min-target-size) - var(--space-1) - var(--space-1));\n  padding: var(--space-1) var(--space-1);\n  /* To account for 32px visual height and 44px target height */\n}\n.rpf-button--sm::before {\n  inset: calc((var(--rpf-button-min-target-size) - var(--rpf-button-sm-height)) / 2) 0;\n}\n.rpf-button--sm.rpf-button--icon-only {\n  height: var(--rpf-button-min-target-size);\n  line-height: var(--rpf-button-min-target-size);\n  padding: 0;\n  width: var(--rpf-button-min-target-size);\n}\n.rpf-button--sm.rpf-button--icon-only::before {\n  inset: calc((var(--rpf-button-min-target-size) - var(--rpf-button-sm-height)) / 2);\n}\n.rpf-button--sm .material-symbols-sharp {\n  font-size: 20px;\n  font-variation-settings: \"OPSZ\" 20;\n}\n";
+styleInject(css_248z);
+
+/* eslint-disable complexity */
+const Button = ({
+  type = "primary",
+  className,
+  enabled = true,
+  active,
+  icon,
+  small = false,
+  onClick = () => {},
+  href,
+  text,
+  title,
+  "aria-label": ariaLabel = "",
+  textOnHover = false,
+  textAlways = false
+}) => {
+  const iconOnly = icon && !textAlways;
+  const classes = classnames("rpf-button", {
+    active: active,
+    disabled: !enabled,
+    "rpf-button--sm": small,
+    // eslint-disable-next-line no-undefined
+    "rpf-button--icon-only": iconOnly,
+    text_on_hover: textOnHover,
+    [`rpf-button--${type}`]: type
+  }, className);
+  const iconClasses = classnames("icon", "rpf-button__icon", {
+    icon_with_text: !textOnHover,
+    icon_without_text: textOnHover,
+    // eslint-disable-next-line no-undefined
+    icon_only: !textOnHover && !text
+  });
+  const content = /*#__PURE__*/React.createElement(React.Fragment, null, icon && /*#__PURE__*/React.createElement("div", {
+    className: iconClasses
+  }, icon), text && !iconOnly && /*#__PURE__*/React.createElement("span", {
+    className: "text"
+  }, text));
+  if (href) {
+    return /*#__PURE__*/React.createElement("a", {
+      className: classes,
+      "aria-label": ariaLabel,
+      href: href,
+      onClick: onClick
+    }, content);
+  }
+  return /*#__PURE__*/React.createElement("button", {
+    className: classes,
+    title: title,
+    "aria-label": ariaLabel,
+    onClick: onClick,
+    disabled: !enabled
+  }, content);
+};
+/* eslint-enable complexity */
+
+Button.propTypes = {
+  type: PropTypes.string,
+  className: PropTypes.string,
+  enabled: PropTypes.bool,
+  active: PropTypes.bool,
+  icon: PropTypes.element,
+  href: PropTypes.string,
+  onClick: PropTypes.func,
+  text: PropTypes.string,
+  title: PropTypes.string,
+  textAlways: PropTypes.bool,
+  "aria-label": PropTypes.string,
+  textOnHover: PropTypes.bool
+};
+
+exports.Button = Button;