@loomhq/lens 10.103.0 → 10.103.2

package/dist/icons/firefox-logo.js

@@ -0,0 +1,2087 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "node_modules/object-assign/index.js"(exports, module) {
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        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;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module.exports = 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;
+    };
+  }
+});
+
+// node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS({
+  "node_modules/react/cjs/react.development.js"(exports) {
+    "use strict";
+    if (true) {
+      (function() {
+        "use strict";
+        var _assign = require_object_assign();
+        var ReactVersion = "17.0.2";
+        var REACT_ELEMENT_TYPE = 60103;
+        var REACT_PORTAL_TYPE = 60106;
+        exports.Fragment = 60107;
+        exports.StrictMode = 60108;
+        exports.Profiler = 60114;
+        var REACT_PROVIDER_TYPE = 60109;
+        var REACT_CONTEXT_TYPE = 60110;
+        var REACT_FORWARD_REF_TYPE = 60112;
+        exports.Suspense = 60113;
+        var REACT_SUSPENSE_LIST_TYPE = 60120;
+        var REACT_MEMO_TYPE = 60115;
+        var REACT_LAZY_TYPE = 60116;
+        var REACT_BLOCK_TYPE = 60121;
+        var REACT_SERVER_BLOCK_TYPE = 60122;
+        var REACT_FUNDAMENTAL_TYPE = 60117;
+        var REACT_SCOPE_TYPE = 60119;
+        var REACT_OPAQUE_ID_TYPE = 60128;
+        var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
+        var REACT_OFFSCREEN_TYPE = 60130;
+        var REACT_LEGACY_HIDDEN_TYPE = 60131;
+        if (typeof Symbol === "function" && Symbol.for) {
+          var symbolFor = Symbol.for;
+          REACT_ELEMENT_TYPE = symbolFor("react.element");
+          REACT_PORTAL_TYPE = symbolFor("react.portal");
+          exports.Fragment = symbolFor("react.fragment");
+          exports.StrictMode = symbolFor("react.strict_mode");
+          exports.Profiler = symbolFor("react.profiler");
+          REACT_PROVIDER_TYPE = symbolFor("react.provider");
+          REACT_CONTEXT_TYPE = symbolFor("react.context");
+          REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
+          exports.Suspense = symbolFor("react.suspense");
+          REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
+          REACT_MEMO_TYPE = symbolFor("react.memo");
+          REACT_LAZY_TYPE = symbolFor("react.lazy");
+          REACT_BLOCK_TYPE = symbolFor("react.block");
+          REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
+          REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
+          REACT_SCOPE_TYPE = symbolFor("react.scope");
+          REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
+          REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
+          REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
+          REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
+        }
+        var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+        var FAUX_ITERATOR_SYMBOL = "@@iterator";
+        function getIteratorFn(maybeIterable) {
+          if (maybeIterable === null || typeof maybeIterable !== "object") {
+            return null;
+          }
+          var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+          if (typeof maybeIterator === "function") {
+            return maybeIterator;
+          }
+          return null;
+        }
+        var ReactCurrentDispatcher = {
+          /**
+           * @internal
+           * @type {ReactComponent}
+           */
+          current: null
+        };
+        var ReactCurrentBatchConfig = {
+          transition: 0
+        };
+        var ReactCurrentOwner = {
+          /**
+           * @internal
+           * @type {ReactComponent}
+           */
+          current: null
+        };
+        var ReactDebugCurrentFrame = {};
+        var currentExtraStackFrame = null;
+        function setExtraStackFrame(stack) {
+          {
+            currentExtraStackFrame = stack;
+          }
+        }
+        {
+          ReactDebugCurrentFrame.setExtraStackFrame = function(stack) {
+            {
+              currentExtraStackFrame = stack;
+            }
+          };
+          ReactDebugCurrentFrame.getCurrentStack = null;
+          ReactDebugCurrentFrame.getStackAddendum = function() {
+            var stack = "";
+            if (currentExtraStackFrame) {
+              stack += currentExtraStackFrame;
+            }
+            var impl = ReactDebugCurrentFrame.getCurrentStack;
+            if (impl) {
+              stack += impl() || "";
+            }
+            return stack;
+          };
+        }
+        var IsSomeRendererActing = {
+          current: false
+        };
+        var ReactSharedInternals = {
+          ReactCurrentDispatcher,
+          ReactCurrentBatchConfig,
+          ReactCurrentOwner,
+          IsSomeRendererActing,
+          // Used by renderers to avoid bundling object-assign twice in UMD bundles:
+          assign: _assign
+        };
+        {
+          ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
+        }
+        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) {
+          {
+            var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
+            var stack = ReactDebugCurrentFrame2.getStackAddendum();
+            if (stack !== "") {
+              format += "%s";
+              args = args.concat([stack]);
+            }
+            var argsWithFormat = args.map(function(item) {
+              return "" + item;
+            });
+            argsWithFormat.unshift("Warning: " + format);
+            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;
+          }
+        }
+        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 emptyObject = {};
+        {
+          Object.freeze(emptyObject);
+        }
+        function Component(props, context, updater) {
+          this.props = props;
+          this.context = context;
+          this.refs = emptyObject;
+          this.updater = updater || ReactNoopUpdateQueue;
+        }
+        Component.prototype.isReactComponent = {};
+        Component.prototype.setState = function(partialState, callback) {
+          if (!(typeof partialState === "object" || typeof partialState === "function" || partialState == null)) {
+            {
+              throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+            }
+          }
+          this.updater.enqueueSetState(this, partialState, callback, "setState");
+        };
+        Component.prototype.forceUpdate = function(callback) {
+          this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+        };
+        {
+          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 void 0;
+              }
+            });
+          };
+          for (var fnName in deprecatedAPIs) {
+            if (deprecatedAPIs.hasOwnProperty(fnName)) {
+              defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+            }
+          }
+        }
+        function ComponentDummy() {
+        }
+        ComponentDummy.prototype = Component.prototype;
+        function PureComponent(props, context, updater) {
+          this.props = props;
+          this.context = context;
+          this.refs = emptyObject;
+          this.updater = updater || ReactNoopUpdateQueue;
+        }
+        var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+        pureComponentPrototype.constructor = PureComponent;
+        _assign(pureComponentPrototype, Component.prototype);
+        pureComponentPrototype.isPureReactComponent = true;
+        function createRef() {
+          var refObject = {
+            current: null
+          };
+          {
+            Object.seal(refObject);
+          }
+          return refObject;
+        }
+        function getWrappedName(outerType, innerType, wrapperName) {
+          var functionName = innerType.displayName || innerType.name || "";
+          return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
+        }
+        function getContextName(type) {
+          return type.displayName || "Context";
+        }
+        function getComponentName(type) {
+          if (type == null) {
+            return null;
+          }
+          {
+            if (typeof type.tag === "number") {
+              error("Received an unexpected object in getComponentName(). 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 exports.Fragment:
+              return "Fragment";
+            case REACT_PORTAL_TYPE:
+              return "Portal";
+            case exports.Profiler:
+              return "Profiler";
+            case exports.StrictMode:
+              return "StrictMode";
+            case exports.Suspense:
+              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:
+                return getComponentName(type.type);
+              case REACT_BLOCK_TYPE:
+                return getComponentName(type._render);
+              case REACT_LAZY_TYPE: {
+                var lazyComponent = type;
+                var payload = lazyComponent._payload;
+                var init = lazyComponent._init;
+                try {
+                  return getComponentName(init(payload));
+                } catch (x) {
+                  return null;
+                }
+              }
+            }
+          }
+          return null;
+        }
+        var hasOwnProperty = Object.prototype.hasOwnProperty;
+        var RESERVED_PROPS = {
+          key: true,
+          ref: true,
+          __self: true,
+          __source: true
+        };
+        var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
+        {
+          didWarnAboutStringRefs = {};
+        }
+        function hasValidRef(config) {
+          {
+            if (hasOwnProperty.call(config, "ref")) {
+              var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
+              if (getter && getter.isReactWarning) {
+                return false;
+              }
+            }
+          }
+          return config.ref !== void 0;
+        }
+        function hasValidKey(config) {
+          {
+            if (hasOwnProperty.call(config, "key")) {
+              var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+              if (getter && getter.isReactWarning) {
+                return false;
+              }
+            }
+          }
+          return config.key !== void 0;
+        }
+        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 = getComponentName(ReactCurrentOwner.current.type);
+              if (!didWarnAboutStringRefs[componentName]) {
+                error('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref);
+                didWarnAboutStringRefs[componentName] = true;
+              }
+            }
+          }
+        }
+        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,
+            key,
+            ref,
+            props,
+            // Record the component responsible for creating this element.
+            _owner: owner
+          };
+          {
+            element._store = {};
+            Object.defineProperty(element._store, "validated", {
+              configurable: false,
+              enumerable: false,
+              writable: true,
+              value: false
+            });
+            Object.defineProperty(element, "_self", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: self
+            });
+            Object.defineProperty(element, "_source", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: source
+            });
+            if (Object.freeze) {
+              Object.freeze(element.props);
+              Object.freeze(element);
+            }
+          }
+          return element;
+        };
+        function createElement2(type, config, children) {
+          var propName;
+          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)) {
+              key = "" + config.key;
+            }
+            self = config.__self === void 0 ? null : config.__self;
+            source = config.__source === void 0 ? null : config.__source;
+            for (propName in config) {
+              if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                props[propName] = config[propName];
+              }
+            }
+          }
+          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;
+          }
+          if (type && type.defaultProps) {
+            var defaultProps = type.defaultProps;
+            for (propName in defaultProps) {
+              if (props[propName] === void 0) {
+                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;
+        }
+        function cloneElement(element, config, children) {
+          if (!!(element === null || element === void 0)) {
+            {
+              throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+            }
+          }
+          var propName;
+          var props = _assign({}, element.props);
+          var key = element.key;
+          var ref = element.ref;
+          var self = element._self;
+          var source = element._source;
+          var owner = element._owner;
+          if (config != null) {
+            if (hasValidRef(config)) {
+              ref = config.ref;
+              owner = ReactCurrentOwner.current;
+            }
+            if (hasValidKey(config)) {
+              key = "" + config.key;
+            }
+            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] === void 0 && defaultProps !== void 0) {
+                  props[propName] = defaultProps[propName];
+                } else {
+                  props[propName] = config[propName];
+                }
+              }
+            }
+          }
+          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);
+        }
+        function isValidElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        var SEPARATOR = ".";
+        var SUBSEPARATOR = ":";
+        function escape(key) {
+          var escapeRegex = /[=:]/g;
+          var escaperLookup = {
+            "=": "=0",
+            ":": "=2"
+          };
+          var escapedString = key.replace(escapeRegex, function(match) {
+            return escaperLookup[match];
+          });
+          return "$" + escapedString;
+        }
+        var didWarnAboutMaps = false;
+        var userProvidedKeyEscapeRegex = /\/+/g;
+        function escapeUserProvidedKey(text) {
+          return text.replace(userProvidedKeyEscapeRegex, "$&/");
+        }
+        function getElementKey(element, index) {
+          if (typeof element === "object" && element !== null && element.key != null) {
+            return escape("" + element.key);
+          }
+          return index.toString(36);
+        }
+        function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+          var type = typeof children;
+          if (type === "undefined" || type === "boolean") {
+            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);
+            var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
+            if (Array.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)) {
+                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
+                    escapeUserProvidedKey("" + mappedChild.key) + "/"
+                  ) : "") + childKey
+                );
+              }
+              array.push(mappedChild);
+            }
+            return 1;
+          }
+          var child;
+          var nextName;
+          var subtreeCount = 0;
+          var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+          if (Array.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;
+              {
+                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") {
+              var childrenString = "" + children;
+              {
+                {
+                  throw Error("Objects are not valid as a React child (found: " + (childrenString === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). If you meant to render a collection of children, use an array instead.");
+                }
+              }
+            }
+          }
+          return subtreeCount;
+        }
+        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;
+        }
+        function countChildren(children) {
+          var n = 0;
+          mapChildren(children, function() {
+            n++;
+          });
+          return n;
+        }
+        function forEachChildren(children, forEachFunc, forEachContext) {
+          mapChildren(children, function() {
+            forEachFunc.apply(this, arguments);
+          }, forEachContext);
+        }
+        function toArray(children) {
+          return mapChildren(children, function(child) {
+            return child;
+          }) || [];
+        }
+        function onlyChild(children) {
+          if (!isValidElement(children)) {
+            {
+              throw Error("React.Children.only expected to receive a single React element child.");
+            }
+          }
+          return children;
+        }
+        function createContext(defaultValue, calculateChangedBits) {
+          if (calculateChangedBits === void 0) {
+            calculateChangedBits = null;
+          } else {
+            {
+              if (calculateChangedBits !== null && typeof calculateChangedBits !== "function") {
+                error("createContext: Expected the optional second argument to be a function. Instead received: %s", calculateChangedBits);
+              }
+            }
+          }
+          var context = {
+            $$typeof: REACT_CONTEXT_TYPE,
+            _calculateChangedBits: calculateChangedBits,
+            // As a workaround to support multiple concurrent renderers, we categorize
+            // some renderers as primary and others as secondary. We only expect
+            // there to be two concurrent renderers at most: React Native (primary) and
+            // 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
+          };
+          context.Provider = {
+            $$typeof: REACT_PROVIDER_TYPE,
+            _context: context
+          };
+          var hasWarnedAboutUsingNestedContextConsumers = false;
+          var hasWarnedAboutUsingConsumerProvider = false;
+          var hasWarnedAboutDisplayNameOnConsumer = false;
+          {
+            var Consumer = {
+              $$typeof: REACT_CONTEXT_TYPE,
+              _context: context,
+              _calculateChangedBits: context._calculateChangedBits
+            };
+            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;
+                  }
+                }
+              }
+            });
+            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();
+            var pending = payload;
+            pending._status = Pending;
+            pending._result = thenable;
+            thenable.then(function(moduleObject) {
+              if (payload._status === Pending) {
+                var defaultExport = moduleObject.default;
+                {
+                  if (defaultExport === void 0) {
+                    error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
+                  }
+                }
+                var resolved = payload;
+                resolved._status = Resolved;
+                resolved._result = defaultExport;
+              }
+            }, function(error2) {
+              if (payload._status === Pending) {
+                var rejected = payload;
+                rejected._status = Rejected;
+                rejected._result = error2;
+              }
+            });
+          }
+          if (payload._status === Resolved) {
+            return payload._result;
+          } else {
+            throw payload._result;
+          }
+        }
+        function lazy(ctor) {
+          var payload = {
+            // We use these fields to store the result.
+            _status: -1,
+            _result: ctor
+          };
+          var lazyType = {
+            $$typeof: REACT_LAZY_TYPE,
+            _payload: payload,
+            _init: lazyInitializer
+          };
+          {
+            var defaultProps;
+            var propTypes;
+            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;
+                  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;
+                  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
+          };
+          {
+            var ownName;
+            Object.defineProperty(elementType, "displayName", {
+              enumerable: false,
+              configurable: true,
+              get: function() {
+                return ownName;
+              },
+              set: function(name) {
+                ownName = name;
+                if (render.displayName == null) {
+                  render.displayName = name;
+                }
+              }
+            });
+          }
+          return elementType;
+        }
+        var enableScopeAPI = false;
+        function isValidElementType(type) {
+          if (typeof type === "string" || typeof type === "function") {
+            return true;
+          }
+          if (type === exports.Fragment || type === exports.Profiler || type === REACT_DEBUG_TRACING_MODE_TYPE || type === exports.StrictMode || type === exports.Suspense || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) {
+            return true;
+          }
+          if (typeof type === "object" && type !== null) {
+            if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
+              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,
+            compare: compare === void 0 ? null : compare
+          };
+          {
+            var ownName;
+            Object.defineProperty(elementType, "displayName", {
+              enumerable: false,
+              configurable: true,
+              get: function() {
+                return ownName;
+              },
+              set: function(name) {
+                ownName = name;
+                if (type.displayName == null) {
+                  type.displayName = name;
+                }
+              }
+            });
+          }
+          return elementType;
+        }
+        function resolveDispatcher() {
+          var dispatcher = ReactCurrentDispatcher.current;
+          if (!(dispatcher !== null)) {
+            {
+              throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
+            }
+          }
+          return dispatcher;
+        }
+        function useContext(Context, unstable_observedBits) {
+          var dispatcher = resolveDispatcher();
+          {
+            if (unstable_observedBits !== void 0) {
+              error("useContext() second argument is reserved for future use in React. Passing it is not supported. You passed: %s.%s", unstable_observedBits, typeof unstable_observedBits === "number" && Array.isArray(arguments[2]) ? "\n\nDid you call array.map(useContext)? Calling Hooks inside a loop is not supported. Learn more at https://reactjs.org/link/rules-of-hooks" : "");
+            }
+            if (Context._context !== void 0) {
+              var realContext = Context._context;
+              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, unstable_observedBits);
+        }
+        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 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);
+          }
+        }
+        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) {
+              prevLog = console.log;
+              prevInfo = console.info;
+              prevWarn = console.warn;
+              prevError = console.error;
+              prevGroup = console.group;
+              prevGroupCollapsed = console.groupCollapsed;
+              prevGroupEnd = console.groupEnd;
+              var props = {
+                configurable: true,
+                enumerable: true,
+                value: disabledLog,
+                writable: true
+              };
+              Object.defineProperties(console, {
+                info: props,
+                log: props,
+                warn: props,
+                error: props,
+                group: props,
+                groupCollapsed: props,
+                groupEnd: props
+              });
+            }
+            disabledDepth++;
+          }
+        }
+        function reenableLogs() {
+          {
+            disabledDepth--;
+            if (disabledDepth === 0) {
+              var props = {
+                configurable: true,
+                enumerable: true,
+                writable: true
+              };
+              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
+                })
+              });
+            }
+            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 === void 0) {
+              try {
+                throw Error();
+              } catch (x) {
+                var match = x.stack.trim().match(/\n( *(at )?)/);
+                prefix = match && match[1] || "";
+              }
+            }
+            return "\n" + prefix + name;
+          }
+        }
+        var reentry = false;
+        var componentFrameCache;
+        {
+          var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+          componentFrameCache = new PossiblyWeakMap();
+        }
+        function describeNativeComponentFrame(fn, construct) {
+          if (!fn || reentry) {
+            return "";
+          }
+          {
+            var frame = componentFrameCache.get(fn);
+            if (frame !== void 0) {
+              return frame;
+            }
+          }
+          var control;
+          reentry = true;
+          var previousPrepareStackTrace = Error.prepareStackTrace;
+          Error.prepareStackTrace = void 0;
+          var previousDispatcher;
+          {
+            previousDispatcher = ReactCurrentDispatcher$1.current;
+            ReactCurrentDispatcher$1.current = null;
+            disableLogs();
+          }
+          try {
+            if (construct) {
+              var Fake = function() {
+                throw Error();
+              };
+              Object.defineProperty(Fake.prototype, "props", {
+                set: function() {
+                  throw Error();
+                }
+              });
+              if (typeof Reflect === "object" && Reflect.construct) {
+                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) {
+            if (sample && control && typeof sample.stack === "string") {
+              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]) {
+                c--;
+              }
+              for (; s >= 1 && c >= 0; s--, c--) {
+                if (sampleLines[s] !== controlLines[c]) {
+                  if (s !== 1 || c !== 1) {
+                    do {
+                      s--;
+                      c--;
+                      if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                        var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
+                        {
+                          if (typeof fn === "function") {
+                            componentFrameCache.set(fn, _frame);
+                          }
+                        }
+                        return _frame;
+                      }
+                    } while (s >= 1 && c >= 0);
+                  }
+                  break;
+                }
+              }
+            }
+          } finally {
+            reentry = false;
+            {
+              ReactCurrentDispatcher$1.current = previousDispatcher;
+              reenableLogs();
+            }
+            Error.prepareStackTrace = previousPrepareStackTrace;
+          }
+          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(Component2) {
+          var prototype = Component2.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 exports.Suspense:
+              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:
+                return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+              case REACT_BLOCK_TYPE:
+                return describeFunctionComponentFrame(type._render);
+              case REACT_LAZY_TYPE: {
+                var lazyComponent = type;
+                var payload = lazyComponent._payload;
+                var init = lazyComponent._init;
+                try {
+                  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) {
+          {
+            var has = Function.call.bind(Object.prototype.hasOwnProperty);
+            for (var typeSpecName in typeSpecs) {
+              if (has(typeSpecs, typeSpecName)) {
+                var error$1 = void 0;
+                try {
+                  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$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)) {
+                  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 = getComponentName(ReactCurrentOwner.current.type);
+            if (name) {
+              return "\n\nCheck the render method of `" + name + "`.";
+            }
+          }
+          return "";
+        }
+        function getSourceInfoErrorAddendum(source) {
+          if (source !== void 0) {
+            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 !== void 0) {
+            return getSourceInfoErrorAddendum(elementProps.__source);
+          }
+          return "";
+        }
+        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;
+        }
+        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;
+          var childOwner = "";
+          if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+            childOwner = " It was passed a child from " + getComponentName(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);
+          }
+        }
+        function validateChildKeys(node, parentType) {
+          if (typeof node !== "object") {
+            return;
+          }
+          if (Array.isArray(node)) {
+            for (var i = 0; i < node.length; i++) {
+              var child = node[i];
+              if (isValidElement(child)) {
+                validateExplicitKey(child, parentType);
+              }
+            }
+          } else if (isValidElement(node)) {
+            if (node._store) {
+              node._store.validated = true;
+            }
+          } else if (node) {
+            var iteratorFn = getIteratorFn(node);
+            if (typeof iteratorFn === "function") {
+              if (iteratorFn !== node.entries) {
+                var iterator = iteratorFn.call(node);
+                var step;
+                while (!(step = iterator.next()).done) {
+                  if (isValidElement(step.value)) {
+                    validateExplicitKey(step.value, parentType);
+                  }
+                }
+              }
+            }
+          }
+        }
+        function validatePropTypes(element) {
+          {
+            var type = element.type;
+            if (type === null || type === void 0 || 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) {
+              var name = getComponentName(type);
+              checkPropTypes(propTypes, element.props, "prop", name, element);
+            } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
+              propTypesMisspellWarningShown = true;
+              var _name = getComponentName(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.");
+            }
+          }
+        }
+        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);
+          if (!validType) {
+            var info = "";
+            if (type === void 0 || 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 (Array.isArray(type)) {
+              typeString = "array";
+            } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
+              typeString = "<" + (getComponentName(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 = createElement2.apply(this, arguments);
+          if (element == null) {
+            return element;
+          }
+          if (validType) {
+            for (var i = 2; i < arguments.length; i++) {
+              validateChildKeys(arguments[i], type);
+            }
+          }
+          if (type === exports.Fragment) {
+            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.");
+            }
+            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;
+        }
+        {
+          try {
+            var frozenObject = Object.freeze({});
+            /* @__PURE__ */ new Map([[frozenObject, null]]);
+            /* @__PURE__ */ new Set([frozenObject]);
+          } catch (e) {
+          }
+        }
+        var createElement$1 = createElementWithValidation;
+        var cloneElement$1 = cloneElementWithValidation;
+        var createFactory = createFactoryWithValidation;
+        var Children = {
+          map: mapChildren,
+          forEach: forEachChildren,
+          count: countChildren,
+          toArray,
+          only: onlyChild
+        };
+        exports.Children = Children;
+        exports.Component = Component;
+        exports.PureComponent = PureComponent;
+        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.useCallback = useCallback;
+        exports.useContext = useContext;
+        exports.useDebugValue = useDebugValue;
+        exports.useEffect = useEffect;
+        exports.useImperativeHandle = useImperativeHandle;
+        exports.useLayoutEffect = useLayoutEffect;
+        exports.useMemo = useMemo;
+        exports.useReducer = useReducer;
+        exports.useRef = useRef;
+        exports.useState = useState;
+        exports.version = ReactVersion;
+      })();
+    }
+  }
+});
+
+// node_modules/react/index.js
+var require_react = __commonJS({
+  "node_modules/react/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_development();
+    }
+  }
+});
+
+// src/components/icon/available-icons/firefox-logo.tsx
+var React = __toESM(require_react());
+function SvgFirefoxLogo(props) {
+  return /* @__PURE__ */ React.createElement(
+    "svg",
+    {
+      width: "96",
+      height: "99",
+      viewBox: "0 0 96 99",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props
+    },
+    /* @__PURE__ */ React.createElement("g", { clipPath: "url(#clip0_2_3887)" }, /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M77.3755 9.37085C74.977 12.1637 73.8599 18.4493 76.292 24.8212C78.7241 31.1931 82.4518 29.8092 84.7755 36.3068C87.8427 44.8806 86.4151 56.3979 86.4151 56.3979C86.4151 56.3979 90.1024 67.0759 92.6719 55.7335C98.3593 34.4291 77.3755 14.6171 77.3755 9.37085Z",
+        fill: "url(#paint0_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M48.1074 97.8203C72.6703 97.8203 92.5685 77.8143 92.5685 53.146C92.5685 28.4776 72.6703 8.4718 48.1312 8.4718C23.5922 8.4718 3.69412 28.4777 3.69412 53.146C3.64654 77.8382 23.5682 97.8203 48.1074 97.8203Z",
+        fill: "url(#paint1_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M81.421 80.6927C80.4599 81.3707 79.4516 81.9793 78.4038 82.5139C79.7918 80.4802 81.0722 78.3753 82.24 76.2077C83.1875 75.159 84.0555 74.1396 84.7628 73.0373C85.1071 72.4958 85.4953 71.8275 85.9062 71.0522C88.4023 66.5551 91.1546 59.2771 91.2327 51.8014V51.7834C91.2345 51.5994 91.2356 51.4153 91.2341 51.231C91.247 49.3545 91.0551 47.4822 90.662 45.6473C90.682 45.7906 90.6996 45.9339 90.7176 46.0771C90.6955 45.9669 90.6769 45.8555 90.6531 45.7452C90.6898 45.9489 90.7192 46.1458 90.7509 46.3444C91.2611 50.673 90.8977 54.8953 89.08 58.0081C89.0514 58.0536 89.0219 58.0961 88.993 58.1406C89.9355 53.4096 90.2508 48.186 89.2021 42.9563C89.2021 42.9563 88.7828 40.4139 85.6589 32.6958C83.8608 28.2534 80.6676 24.6112 77.8464 21.9579C75.3734 18.8984 73.1274 16.8452 71.8893 15.5416C69.3031 12.8184 68.2191 10.7771 67.774 9.44518C67.3881 9.25167 62.452 4.4565 62.0599 4.2738C59.9053 7.61435 53.1294 18.0634 56.3527 27.8261C57.8134 32.2504 61.5076 36.8422 65.3738 39.4182C65.5436 39.6121 67.6744 41.9264 68.6877 47.1463C69.734 52.5391 69.1839 56.7472 67.0304 62.9699C64.4978 68.4292 58.0093 73.8261 51.9339 74.3782C38.9455 75.5582 34.1906 67.8569 34.1906 67.8569C38.8316 69.7124 43.963 69.3243 47.0836 67.4006C50.2287 65.455 52.1311 64.0125 53.6752 64.5813C55.1976 65.1475 56.4096 63.504 55.322 61.8001C54.4822 60.5066 53.2804 59.4886 51.8664 58.8729C50.4523 58.2571 48.8884 58.0709 47.3693 58.3373C44.221 58.849 41.337 61.343 37.2118 58.9277C36.9448 58.7727 36.6864 58.6035 36.4377 58.4206C36.1658 58.2419 37.3217 58.6928 37.052 58.4896C36.2492 58.0535 34.8284 57.1031 34.4598 56.7651C34.3984 56.7088 35.0827 56.9833 35.0213 56.927C31.1642 53.7507 31.6459 51.605 31.7671 50.2593C31.8642 49.1827 32.5648 47.803 33.7454 47.2435C34.3156 47.5546 34.6709 47.7922 34.6709 47.7922C34.6709 47.7922 34.4277 47.2953 34.2962 47.0334C34.3422 47.0134 34.3863 47.0187 34.4322 46.9992C34.8993 47.2246 35.9323 47.8105 36.4762 48.1677C37.1845 48.6673 37.4103 49.1128 37.4103 49.1128C37.4103 49.1128 37.5967 49.0102 37.4588 48.5745C37.4087 48.3958 37.1937 47.828 36.4921 47.255L36.536 47.2599C36.9559 47.4992 37.3537 47.7754 37.7246 48.0853C37.9224 47.3661 38.2781 46.6151 38.1999 45.2716C38.1521 44.327 38.1742 44.0824 38.0077 43.7176C37.8587 43.4043 38.0912 43.2821 38.3501 43.6074C38.3058 43.3525 38.2315 43.1038 38.1289 42.8663L38.1311 42.8418C38.4541 41.7164 44.9668 38.7892 45.4409 38.4471C46.2198 37.896 46.8729 37.1859 47.3572 36.3637C47.7194 35.7865 47.9919 34.9767 48.0583 33.7484C48.0938 32.8625 47.6818 32.2726 41.0965 31.5831C39.2955 31.4057 38.2388 30.1007 37.6383 28.8965C37.5287 28.6371 37.4171 28.402 37.3053 28.1671C37.1986 27.8926 37.1129 27.6103 37.0491 27.3227C38.1257 24.2304 39.9347 21.6159 42.5946 19.6404C42.7396 19.5084 42.0155 19.6742 42.1604 19.5422C42.3293 19.3882 43.433 18.9436 43.6414 18.8434C43.896 18.7232 42.5515 18.1523 41.3646 18.2913C40.1557 18.4276 39.899 18.5718 39.2539 18.8453C39.5216 18.5788 40.373 18.2294 40.1734 18.2317C38.8702 18.4316 37.2508 19.1891 35.8665 20.047C35.8638 19.8976 35.8923 19.7493 35.9501 19.6115C35.305 19.8852 33.7206 20.9926 33.2593 21.9295C33.2792 21.7499 33.2881 21.5693 33.286 21.3886C32.7945 21.7985 32.3511 22.2628 31.9643 22.7726L31.9402 22.7945C28.1984 21.2871 24.9056 21.1896 22.1192 21.8654C21.5096 21.2533 21.2118 21.7008 19.8248 18.6534C19.7306 18.4699 19.8971 18.8346 19.8248 18.6534C19.5967 18.0625 19.9639 19.4419 19.8248 18.6534C17.4927 20.4936 14.4242 22.579 12.9512 24.051C12.933 24.1097 14.6696 23.5603 12.9512 24.051C12.3495 24.2229 12.3903 24.58 12.2989 27.8071C12.2768 28.0518 12.2964 28.3258 12.2765 28.546C11.0999 30.0452 10.2985 31.3148 9.99539 31.9726C8.47366 34.5948 6.79768 38.6826 5.17308 45.1488C5.88966 43.3961 6.7536 41.7073 7.75561 40.1006C6.40465 43.5328 5.09866 48.9225 4.83754 57.2225C5.16435 55.5098 5.58339 53.816 6.09285 52.1484C5.77391 59.0344 6.96139 65.907 9.57242 72.2867C10.5068 74.5725 12.0524 78.0414 14.6835 81.842C22.95 90.5398 34.6099 95.9546 47.5212 95.9546C61 95.9547 73.1037 90.0574 81.421 80.6927Z",
+        fill: "url(#paint2_linear_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M71.4475 87.01C87.7606 85.121 94.9821 68.3101 85.7084 67.9796C77.3317 67.7118 63.7206 87.9014 71.4475 87.01Z",
+        fill: "url(#paint3_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M86.8829 64.5457C98.1065 58.0138 95.1801 43.9047 95.1801 43.9047C95.1801 43.9047 90.8486 48.9365 87.9059 56.9575C84.9992 64.9002 80.1351 68.4908 86.8829 64.5457Z",
+        fill: "url(#paint4_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M51.2526 95.3589C66.9003 100.352 80.3492 88.0251 72.0592 83.9085C64.522 80.196 43.8257 92.9979 51.2526 95.3589Z",
+        fill: "url(#paint5_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M88.049 70.5362C88.4296 69.9991 88.9444 68.2791 89.3991 67.5103C92.1618 63.0509 92.1813 59.4952 92.1813 59.4137C93.8499 51.0785 93.6985 47.675 92.6721 41.3806C91.8456 36.3125 88.2328 29.0517 85.103 25.5553C81.8778 21.953 84.15 23.1267 81.0272 20.4954C78.2902 17.4612 75.6363 14.4566 74.191 13.2483C63.7467 4.5166 63.9827 2.66193 64.1838 2.34573C64.1498 2.38289 64.1 2.43808 64.0364 2.51029C63.9127 2.0172 63.8253 1.60254 63.8253 1.60254C63.8253 1.60254 58.1162 7.31167 56.9143 16.8269C56.1296 23.0389 58.455 29.5148 61.8221 33.6538C63.5754 35.7988 65.5569 37.7467 67.7316 39.4631V39.4605C70.2756 43.1141 71.6759 47.6225 71.6759 52.4722C71.6759 64.6161 61.826 74.4605 49.6755 74.4605C48.0195 74.4614 46.3687 74.2759 44.7542 73.9077C39.0214 72.8152 35.7109 69.9233 34.0599 67.96C33.1137 66.8348 32.7113 66.0146 32.7113 66.0146C37.8479 67.8547 43.5272 67.4697 46.981 65.5621C50.4614 63.6325 52.5673 62.2021 54.2763 62.7661C55.961 63.3276 57.3023 61.6977 56.0993 60.0081C54.9203 58.3209 51.8525 55.9045 47.2974 56.574C43.8129 57.0815 40.621 59.5548 36.0554 57.1594C35.7613 57.0067 35.4754 56.8388 35.1986 56.6566C34.8976 56.4792 36.177 56.9266 35.8784 56.7249C34.99 56.2924 33.4172 55.3499 33.0095 55.0148C32.9415 54.959 33.6989 55.2312 33.6305 55.1751C29.3616 52.0251 29.8945 49.8973 30.0288 48.5627C30.1363 47.495 30.9117 46.1268 32.2182 45.5719C32.8493 45.8805 33.2425 46.1161 33.2425 46.1161C33.2425 46.1161 32.9733 45.6233 32.8277 45.3636C32.8787 45.3441 32.9273 45.349 32.978 45.3296C33.495 45.5532 34.6382 46.1338 35.2402 46.4885C36.0241 46.984 36.274 47.4258 36.274 47.4258C36.274 47.4258 36.4805 47.324 36.3277 46.8919C36.2719 46.7147 36.0344 46.1516 35.2578 45.5833L35.3064 45.5882C35.7674 45.8232 36.2075 46.0971 36.6219 46.4068C36.8408 45.6936 37.2347 44.9488 37.148 43.6165C37.0951 42.6798 37.1196 42.4371 36.9353 42.0754C36.7703 41.7649 37.0278 41.6435 37.3141 41.9664C37.2646 41.7117 37.1823 41.4645 37.0693 41.2309L37.0718 41.2067C37.4294 40.0906 44.6374 37.1878 45.1621 36.8484C46.0075 36.3178 46.7304 35.6134 47.283 34.7821C47.6836 34.2097 47.9855 33.4066 48.059 32.1885C48.0836 31.6396 47.9147 31.2052 46.0057 30.7897C44.86 30.5403 43.0874 30.2977 40.3534 30.0411C38.3602 29.8653 37.1906 28.5712 36.526 27.3769C36.4047 27.1196 36.2812 26.8861 36.1575 26.6535C36.0399 26.3828 35.945 26.1027 35.8739 25.8162C37.0666 22.6938 39.2146 20.0276 42.0116 18.1977C42.1719 18.0667 41.3706 18.2312 41.5308 18.1003C41.7179 17.9476 42.9394 17.5067 43.1702 17.4073C43.4519 17.2885 41.9638 16.7222 40.6502 16.8599C39.3124 16.995 39.0282 17.1379 38.3142 17.4093C38.6106 17.145 39.5528 16.7984 39.3319 16.8009C37.8896 16.999 36.0968 17.7503 34.5643 18.601C34.5615 18.4519 34.5932 18.3041 34.6569 18.1691C33.9428 18.4405 32.1892 19.5387 31.6787 20.4678C31.7006 20.2899 31.7105 20.1108 31.7081 19.9316C31.1704 20.3323 30.6799 20.7926 30.2458 21.3038L30.219 21.3256C26.0777 19.8307 22.4334 19.7339 19.3495 20.4041C18.6748 19.7971 17.59 18.8791 16.055 15.8568C15.9507 15.6749 15.8947 16.2329 15.8146 16.0533C15.2181 14.6697 14.8578 12.403 14.917 10.8403C14.917 10.8403 13.6832 11.4026 12.6621 13.751C12.4725 14.1732 12.3509 14.406 12.2294 14.6389C12.1735 14.7068 12.3561 13.8677 12.3269 13.9133C12.1494 14.2138 11.6903 14.6337 11.4885 15.1772C11.3499 15.5799 11.1554 15.8055 11.0313 16.3078L11.0022 16.3538C10.9922 16.2058 11.039 15.7448 11.0049 15.8393C10.5263 16.8063 10.1144 17.805 9.77213 18.8282C9.22235 20.6357 8.58233 23.096 8.48087 26.2966C8.45643 26.5393 8.47816 26.8111 8.45613 27.0295C7.15405 28.5163 6.26683 29.7752 5.93139 30.4278C4.248 33.029 2.39303 37.0829 0.594851 43.4955C1.39488 41.7438 2.35156 40.068 3.45322 38.4886C1.95793 41.8923 0.512519 47.2374 0.223557 55.4687C0.58652 53.7653 1.05048 52.085 1.61298 50.4367C1.35477 55.9255 1.99409 62.7303 5.46404 70.4079C7.52434 74.9239 12.267 84.0947 23.8555 91.2513L23.8545 91.252C23.8545 91.252 27.7968 94.1867 34.5733 96.3861C35.0741 96.5678 35.5814 96.7467 36.0992 96.9202C35.9367 96.8546 35.7795 96.7856 35.6269 96.7147C40.1374 98.0661 44.8205 98.7544 49.5291 98.758C67.0752 98.7729 72.2501 91.7267 72.2501 91.7267C72.2501 91.7267 72.2319 91.7405 72.1987 91.7645C72.4463 91.5314 72.6848 91.2891 72.9142 91.0376C70.1458 93.6518 63.8281 93.8253 61.4658 93.6367C65.4946 92.4535 68.1456 91.4526 73.3023 89.4781C73.9057 89.2545 74.5228 88.9994 75.1534 88.7129C75.2216 88.6829 75.2905 88.6503 75.359 88.6192C75.4841 88.5609 75.608 88.5058 75.7343 88.4445C78.2467 87.2605 80.6092 85.7815 82.7717 84.0387C87.95 79.9021 89.0767 75.87 89.6657 73.2114C89.5835 73.4662 89.3276 74.0603 89.1478 74.445C87.8142 77.2978 84.8569 79.0483 81.645 80.5496C83.1734 78.5442 84.5907 76.4566 85.8906 74.2962C86.939 73.2562 87.2661 71.6294 88.049 70.5362Z",
+        fill: "url(#paint6_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M81.7461 80.4269C83.8575 78.0991 85.7535 75.4365 87.1897 72.4173C90.8856 64.6466 96.6 51.7262 92.0994 38.232C88.5424 27.5666 83.6587 21.7348 77.4578 16.0379C67.3873 6.78646 64.5747 2.65635 64.5747 0.200317C64.5747 0.200317 52.9472 13.162 57.99 26.6808C63.0328 40.1996 73.3606 39.704 80.1934 53.8116C88.2338 70.4127 73.6881 88.5285 61.6594 93.5991C62.3958 93.4355 88.3991 87.5511 89.7657 72.6774C89.7348 72.9509 89.1488 77.0647 81.7461 80.4269Z",
+        fill: "url(#paint7_radial_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M48.0593 32.1888C48.0987 31.3104 47.643 30.7205 40.3788 30.0391C37.3901 29.7631 36.2457 27.0008 35.8968 25.8383C34.8341 28.5992 34.3953 31.4963 34.6312 35.0006C34.7925 37.2963 36.3348 39.7603 37.0721 41.207C37.0721 41.207 37.236 40.9941 37.3116 40.9154C38.6999 39.47 44.5167 37.2676 45.0632 36.9549C45.6656 36.5744 47.9581 34.8994 48.0593 32.1888Z",
+        fill: "url(#paint8_linear_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M16.0803 15.8725C15.9761 15.6904 15.9201 16.2485 15.8399 16.0689C15.2435 14.6854 14.8806 12.4431 14.9665 10.8584C14.9665 10.8584 13.7328 11.4207 12.7116 13.7691C12.522 14.1912 12.4004 14.4241 12.2789 14.657C12.2231 14.7249 12.4057 13.8857 12.3765 13.9314C12.1991 14.2319 11.74 14.6518 11.5406 15.1709C11.3752 15.5955 11.2051 15.8234 11.0785 16.35C11.0396 16.4931 11.1178 15.7167 11.0837 15.8112C8.70884 20.4011 8.25551 27.3411 8.50581 27.0476C13.5617 21.649 19.3557 20.3686 19.3557 20.3686C18.7392 19.9145 17.3997 18.6033 16.0804 15.8725H16.0803Z",
+        fill: "url(#paint9_linear_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M35.264 72.3257C28.2804 69.344 20.3409 65.1387 20.6406 55.5851C21.0488 43.0031 32.3739 45.4899 32.3739 45.4899C31.9465 45.5939 30.8039 46.4075 30.3989 47.2747C29.971 48.3592 29.1901 50.808 31.5559 53.3745C35.2707 57.4001 23.9237 62.9254 41.438 73.3632C41.8797 73.6036 37.3323 73.2199 35.2642 72.3257H35.264Z",
+        fill: "url(#paint10_linear_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M32.7831 66.0557C37.7352 67.7791 43.5042 67.4768 46.958 65.5691C49.2702 64.2819 52.2365 62.2203 54.0616 62.7292C52.4814 62.1046 51.2846 61.8128 49.8449 61.7415C49.5997 61.7415 49.3058 61.7363 49.0388 61.7094C48.5115 61.7077 47.9845 61.7366 47.4605 61.7958C46.5691 61.8778 45.5809 62.4402 44.6826 62.3499C44.634 62.345 45.554 61.9719 45.4792 61.9889C45.0032 62.0881 44.4861 62.1096 43.9397 62.1773C43.5924 62.2159 43.2938 62.2594 42.949 62.2737C32.6343 63.1484 23.9169 56.6835 23.9169 56.6835C23.1749 59.1825 27.2388 64.1254 32.7832 66.0557H32.7831Z",
+        fill: "url(#paint11_linear_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M81.7278 80.4934C92.1607 70.25 97.4391 57.7986 95.2076 43.8328C95.2076 43.8328 96.0991 50.9943 92.7189 58.3188C94.3428 51.1681 94.5317 42.2818 90.2173 33.0796C84.4588 20.7969 74.9882 14.3338 71.3725 11.6375C65.8942 7.55209 63.6233 3.39243 63.5823 2.53406C61.9458 5.88712 56.9952 17.3778 63.0505 27.2736C68.7236 36.5449 77.6604 39.2968 83.9167 47.8012C95.4426 63.4683 81.7278 80.4934 81.7278 80.4934Z",
+        fill: "url(#paint12_linear_2_3887)"
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "path",
+      {
+        d: "M80.233 53.8412C76.5869 46.3091 72.0363 43.0238 67.7316 39.4631C68.2324 40.1643 68.3558 40.412 68.633 40.8654C72.4218 44.9034 78.0087 54.7532 73.9525 67.1181C66.3174 90.3928 35.7771 79.4328 32.5753 76.3541C33.8706 89.8245 56.4171 96.2704 71.0969 87.535C79.4503 79.6274 86.2079 66.1847 80.233 53.8412Z",
+        fill: "url(#paint13_linear_2_3887)"
+      }
+    )),
+    /* @__PURE__ */ React.createElement("defs", null, /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint0_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(91.188 24.8595) rotate(2.55481) scale(34.446 50.6293)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.045", stopColor: "#FFEA00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.12", stopColor: "#FFDE00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.254", stopColor: "#FFBF00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.429", stopColor: "#FF8E00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.769", stopColor: "#FF272D" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.872", stopColor: "#E0255A" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.953", stopColor: "#CC2477" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#C42482" })
+    ), /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint1_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(66.6417 19.5445) scale(97.0809 97.0809)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#00CCDA" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.22", stopColor: "#0083FF" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.261", stopColor: "#007AF9" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.33", stopColor: "#0060E8" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.333", stopColor: "#005FE7" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.438", stopColor: "#2639AD" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.522", stopColor: "#401E84" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.566", stopColor: "#4A1475" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint2_linear_2_3887",
+        x1: "54.3771",
+        y1: "73.2359",
+        x2: "35.2026",
+        y2: "10.5128",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#000F43", stopOpacity: "0.4" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.485", stopColor: "#001962", stopOpacity: "0.173" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#002079", stopOpacity: "0" })
+    ), /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint3_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(99.6542 63.8474) rotate(5.76178) scale(32.751 32.751)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.003", stopColor: "#FFEA00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.497", stopColor: "#FF272D" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#C42482" })
+    ), /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint4_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(99.8587 32.3043) rotate(5.76178) scale(54.6915)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.003", stopColor: "#FFE900" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.157", stopColor: "#FFAF0E" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.316", stopColor: "#FF7A1B" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.472", stopColor: "#FF4E26" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.621", stopColor: "#FF2C2E" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.762", stopColor: "#FF1434" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.892", stopColor: "#FF0538" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#FF0039" })
+    ), /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint5_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(102.465 83.5229) rotate(5.76178) scale(50.1854 50.1854)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.003", stopColor: "#FF272D" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.497", stopColor: "#C42482" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.986", stopColor: "#620700" })
+    ), /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint6_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(71.8571 39.6675) scale(78.3434)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.156", stopColor: "#FFEA00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.231", stopColor: "#FFDE00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.365", stopColor: "#FFBF00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.541", stopColor: "#FF8E00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.763", stopColor: "#FF272D" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.796", stopColor: "#F92433" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.841", stopColor: "#E91C45" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.893", stopColor: "#CF0E62" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.935", stopColor: "#B5007F" })
+    ), /* @__PURE__ */ React.createElement(
+      "radialGradient",
+      {
+        id: "paint7_radial_2_3887",
+        cx: "0",
+        cy: "0",
+        r: "1",
+        gradientUnits: "userSpaceOnUse",
+        gradientTransform: "translate(65.9626 0.329422) scale(92.5095 92.5095)"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.279", stopColor: "#FFEA00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.402", stopColor: "#FFDD00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.63", stopColor: "#FFBA00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.856", stopColor: "#FF9100" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.933", stopColor: "#FF6711" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.994", stopColor: "#FF4A1D" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint8_linear_2_3887",
+        x1: "18.1622",
+        y1: "35.7443",
+        x2: "53.7743",
+        y2: "30.3976",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#C42482", stopOpacity: "0.5" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.474", stopColor: "#FF272D", stopOpacity: "0.5" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.486", stopColor: "#FF2C2C", stopOpacity: "0.513" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.675", stopColor: "#FF7A1A", stopOpacity: "0.72" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.829", stopColor: "#FFB20D", stopOpacity: "0.871" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.942", stopColor: "#FFD605", stopOpacity: "0.964" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#FFE302" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint9_linear_2_3887",
+        x1: "14.6091",
+        y1: "26.2294",
+        x2: "10.5712",
+        y2: "11.7457",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#891551", stopOpacity: "0.6" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#C42482", stopOpacity: "0" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint10_linear_2_3887",
+        x1: "22.2714",
+        y1: "47.2126",
+        x2: "30.5813",
+        y2: "58.806",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.005", stopColor: "#891551", stopOpacity: "0.5" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.484", stopColor: "#FF272D", stopOpacity: "0.5" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#FF272D", stopOpacity: "0" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint11_linear_2_3887",
+        x1: "38.1594",
+        y1: "67.5089",
+        x2: "38.9138",
+        y2: "60.0569",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#C42482" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.083", stopColor: "#C42482", stopOpacity: "0.81" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.206", stopColor: "#C42482", stopOpacity: "0.565" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.328", stopColor: "#C42482", stopOpacity: "0.362" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.447", stopColor: "#C42482", stopOpacity: "0.204" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.562", stopColor: "#C42482", stopOpacity: "0.091" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.673", stopColor: "#C42482", stopOpacity: "0.023" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.773", stopColor: "#C42482", stopOpacity: "0" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint12_linear_2_3887",
+        x1: "62.3761",
+        y1: "3.81811",
+        x2: "92.9907",
+        y2: "72.2772",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#FFF14F" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.268", stopColor: "#FFEE4C" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.452", stopColor: "#FFE643" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.612", stopColor: "#FFD834" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.757", stopColor: "#FFC41E" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.892", stopColor: "#FFAB02" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.902", stopColor: "#FFA900" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.949", stopColor: "#FFA000" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#FF9100" })
+    ), /* @__PURE__ */ React.createElement(
+      "linearGradient",
+      {
+        id: "paint13_linear_2_3887",
+        x1: "68.4212",
+        y1: "43.1901",
+        x2: "53.9193",
+        y2: "82.1274",
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ React.createElement("stop", { stopColor: "#FF8E00" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.04", stopColor: "#FF8E00", stopOpacity: "0.858" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.084", stopColor: "#FF8E00", stopOpacity: "0.729" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.13", stopColor: "#FF8E00", stopOpacity: "0.628" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.178", stopColor: "#FF8E00", stopOpacity: "0.557" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.227", stopColor: "#FF8E00", stopOpacity: "0.514" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.282", stopColor: "#FF8E00", stopOpacity: "0.5" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.389", stopColor: "#FF8E00", stopOpacity: "0.478" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.524", stopColor: "#FF8E00", stopOpacity: "0.416" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.676", stopColor: "#FF8E00", stopOpacity: "0.314" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "0.838", stopColor: "#FF8E00", stopOpacity: "0.172" }),
+      /* @__PURE__ */ React.createElement("stop", { offset: "1", stopColor: "#FF8E00", stopOpacity: "0" })
+    ), /* @__PURE__ */ React.createElement("clipPath", { id: "clip0_2_3887" }, /* @__PURE__ */ React.createElement("rect", { width: "96", height: "98.8718", fill: "white" })))
+  );
+}
+export {
+  SvgFirefoxLogo
+};
+/*! Bundled license information:
+
+object-assign/index.js:
+  (*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  *)
+
+react/cjs/react.development.js:
+  (** @license React v17.0.2
+   * 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.
+   *)
+*/