@tmlmobilidade/ui 20250306.1750.41 → 20250307.1322.1

package/dist/esm/_virtual/jsx-runtime.js

@@ -0,0 +1,4 @@
+var jsxRuntime = {exports: {}};
+
+export { jsxRuntime as __module };
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/esm/_virtual/jsx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/esm/_virtual/react-jsx-runtime.development.js

@@ -0,0 +1,4 @@
+var reactJsxRuntime_development = {};
+
+export { reactJsxRuntime_development as __exports };
+//# sourceMappingURL=react-jsx-runtime.development.js.map

package/dist/esm/_virtual/react-jsx-runtime.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-jsx-runtime.development.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/esm/_virtual/react-jsx-runtime.production.js

@@ -0,0 +1,4 @@
+var reactJsxRuntime_production = {};
+
+export { reactJsxRuntime_production as __exports };
+//# sourceMappingURL=react-jsx-runtime.production.js.map

package/dist/esm/_virtual/react-jsx-runtime.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-jsx-runtime.production.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/esm/node_modules/react/cjs/react-jsx-runtime.development.js

@@ -0,0 +1,667 @@
+import { __exports as reactJsxRuntime_development } from '../../../_virtual/react-jsx-runtime.development.js';
+import React__default from 'react';
+
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_development;
+
+function requireReactJsxRuntime_development () {
+	if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+	hasRequiredReactJsxRuntime_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function getComponentNameFromType(type) {
+	      if (null == type) return null;
+	      if ("function" === typeof type)
+	        return type.$$typeof === REACT_CLIENT_REFERENCE$2
+	          ? null
+	          : type.displayName || type.name || null;
+	      if ("string" === typeof type) return type;
+	      switch (type) {
+	        case REACT_FRAGMENT_TYPE:
+	          return "Fragment";
+	        case REACT_PORTAL_TYPE:
+	          return "Portal";
+	        case REACT_PROFILER_TYPE:
+	          return "Profiler";
+	        case REACT_STRICT_MODE_TYPE:
+	          return "StrictMode";
+	        case REACT_SUSPENSE_TYPE:
+	          return "Suspense";
+	        case REACT_SUSPENSE_LIST_TYPE:
+	          return "SuspenseList";
+	      }
+	      if ("object" === typeof type)
+	        switch (
+	          ("number" === typeof type.tag &&
+	            console.error(
+	              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+	            ),
+	          type.$$typeof)
+	        ) {
+	          case REACT_CONTEXT_TYPE:
+	            return (type.displayName || "Context") + ".Provider";
+	          case REACT_CONSUMER_TYPE:
+	            return (type._context.displayName || "Context") + ".Consumer";
+	          case REACT_FORWARD_REF_TYPE:
+	            var innerType = type.render;
+	            type = type.displayName;
+	            type ||
+	              ((type = innerType.displayName || innerType.name || ""),
+	              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
+	            return type;
+	          case REACT_MEMO_TYPE:
+	            return (
+	              (innerType = type.displayName || null),
+	              null !== innerType
+	                ? innerType
+	                : getComponentNameFromType(type.type) || "Memo"
+	            );
+	          case REACT_LAZY_TYPE:
+	            innerType = type._payload;
+	            type = type._init;
+	            try {
+	              return getComponentNameFromType(type(innerType));
+	            } catch (x) {}
+	        }
+	      return null;
+	    }
+	    function testStringCoercion(value) {
+	      return "" + value;
+	    }
+	    function checkKeyStringCoercion(value) {
+	      try {
+	        testStringCoercion(value);
+	        var JSCompiler_inline_result = !1;
+	      } catch (e) {
+	        JSCompiler_inline_result = true;
+	      }
+	      if (JSCompiler_inline_result) {
+	        JSCompiler_inline_result = console;
+	        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+	        var JSCompiler_inline_result$jscomp$0 =
+	          ("function" === typeof Symbol &&
+	            Symbol.toStringTag &&
+	            value[Symbol.toStringTag]) ||
+	          value.constructor.name ||
+	          "Object";
+	        JSCompiler_temp_const.call(
+	          JSCompiler_inline_result,
+	          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+	          JSCompiler_inline_result$jscomp$0
+	        );
+	        return testStringCoercion(value);
+	      }
+	    }
+	    function disabledLog() {}
+	    function disableLogs() {
+	      if (0 === disabledDepth) {
+	        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 (0 === disabledDepth) {
+	        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 })
+	        });
+	      }
+	      0 > disabledDepth &&
+	        console.error(
+	          "disabledDepth fell below zero. This is a bug in React. Please file an issue."
+	        );
+	    }
+	    function describeBuiltInComponentFrame(name) {
+	      if (void 0 === prefix)
+	        try {
+	          throw Error();
+	        } catch (x) {
+	          var match = x.stack.trim().match(/\n( *(at )?)/);
+	          prefix = (match && match[1]) || "";
+	          suffix =
+	            -1 < x.stack.indexOf("\n    at")
+	              ? " (<anonymous>)"
+	              : -1 < x.stack.indexOf("@")
+	                ? "@unknown:0:0"
+	                : "";
+	        }
+	      return "\n" + prefix + name + suffix;
+	    }
+	    function describeNativeComponentFrame(fn, construct) {
+	      if (!fn || reentry) return "";
+	      var frame = componentFrameCache.get(fn);
+	      if (void 0 !== frame) return frame;
+	      reentry = true;
+	      frame = Error.prepareStackTrace;
+	      Error.prepareStackTrace = void 0;
+	      var previousDispatcher = null;
+	      previousDispatcher = ReactSharedInternals.H;
+	      ReactSharedInternals.H = null;
+	      disableLogs();
+	      try {
+	        var RunInRootFrame = {
+	          DetermineComponentFrameRoot: function () {
+	            try {
+	              if (construct) {
+	                var Fake = function () {
+	                  throw Error();
+	                };
+	                Object.defineProperty(Fake.prototype, "props", {
+	                  set: function () {
+	                    throw Error();
+	                  }
+	                });
+	                if ("object" === typeof Reflect && Reflect.construct) {
+	                  try {
+	                    Reflect.construct(Fake, []);
+	                  } catch (x) {
+	                    var control = x;
+	                  }
+	                  Reflect.construct(fn, [], Fake);
+	                } else {
+	                  try {
+	                    Fake.call();
+	                  } catch (x$0) {
+	                    control = x$0;
+	                  }
+	                  fn.call(Fake.prototype);
+	                }
+	              } else {
+	                try {
+	                  throw Error();
+	                } catch (x$1) {
+	                  control = x$1;
+	                }
+	                (Fake = fn()) &&
+	                  "function" === typeof Fake.catch &&
+	                  Fake.catch(function () {});
+	              }
+	            } catch (sample) {
+	              if (sample && control && "string" === typeof sample.stack)
+	                return [sample.stack, control.stack];
+	            }
+	            return [null, null];
+	          }
+	        };
+	        RunInRootFrame.DetermineComponentFrameRoot.displayName =
+	          "DetermineComponentFrameRoot";
+	        var namePropDescriptor = Object.getOwnPropertyDescriptor(
+	          RunInRootFrame.DetermineComponentFrameRoot,
+	          "name"
+	        );
+	        namePropDescriptor &&
+	          namePropDescriptor.configurable &&
+	          Object.defineProperty(
+	            RunInRootFrame.DetermineComponentFrameRoot,
+	            "name",
+	            { value: "DetermineComponentFrameRoot" }
+	          );
+	        var _RunInRootFrame$Deter =
+	            RunInRootFrame.DetermineComponentFrameRoot(),
+	          sampleStack = _RunInRootFrame$Deter[0],
+	          controlStack = _RunInRootFrame$Deter[1];
+	        if (sampleStack && controlStack) {
+	          var sampleLines = sampleStack.split("\n"),
+	            controlLines = controlStack.split("\n");
+	          for (
+	            _RunInRootFrame$Deter = namePropDescriptor = 0;
+	            namePropDescriptor < sampleLines.length &&
+	            !sampleLines[namePropDescriptor].includes(
+	              "DetermineComponentFrameRoot"
+	            );
+
+	          )
+	            namePropDescriptor++;
+	          for (
+	            ;
+	            _RunInRootFrame$Deter < controlLines.length &&
+	            !controlLines[_RunInRootFrame$Deter].includes(
+	              "DetermineComponentFrameRoot"
+	            );
+
+	          )
+	            _RunInRootFrame$Deter++;
+	          if (
+	            namePropDescriptor === sampleLines.length ||
+	            _RunInRootFrame$Deter === controlLines.length
+	          )
+	            for (
+	              namePropDescriptor = sampleLines.length - 1,
+	                _RunInRootFrame$Deter = controlLines.length - 1;
+	              1 <= namePropDescriptor &&
+	              0 <= _RunInRootFrame$Deter &&
+	              sampleLines[namePropDescriptor] !==
+	                controlLines[_RunInRootFrame$Deter];
+
+	            )
+	              _RunInRootFrame$Deter--;
+	          for (
+	            ;
+	            1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter;
+	            namePropDescriptor--, _RunInRootFrame$Deter--
+	          )
+	            if (
+	              sampleLines[namePropDescriptor] !==
+	              controlLines[_RunInRootFrame$Deter]
+	            ) {
+	              if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
+	                do
+	                  if (
+	                    (namePropDescriptor--,
+	                    _RunInRootFrame$Deter--,
+	                    0 > _RunInRootFrame$Deter ||
+	                      sampleLines[namePropDescriptor] !==
+	                        controlLines[_RunInRootFrame$Deter])
+	                  ) {
+	                    var _frame =
+	                      "\n" +
+	                      sampleLines[namePropDescriptor].replace(
+	                        " at new ",
+	                        " at "
+	                      );
+	                    fn.displayName &&
+	                      _frame.includes("<anonymous>") &&
+	                      (_frame = _frame.replace("<anonymous>", fn.displayName));
+	                    "function" === typeof fn &&
+	                      componentFrameCache.set(fn, _frame);
+	                    return _frame;
+	                  }
+	                while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
+	              }
+	              break;
+	            }
+	        }
+	      } finally {
+	        (reentry = false),
+	          (ReactSharedInternals.H = previousDispatcher),
+	          reenableLogs(),
+	          (Error.prepareStackTrace = frame);
+	      }
+	      sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "")
+	        ? describeBuiltInComponentFrame(sampleLines)
+	        : "";
+	      "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
+	      return sampleLines;
+	    }
+	    function describeUnknownElementTypeFrameInDEV(type) {
+	      if (null == type) return "";
+	      if ("function" === typeof type) {
+	        var prototype = type.prototype;
+	        return describeNativeComponentFrame(
+	          type,
+	          !(!prototype || !prototype.isReactComponent)
+	        );
+	      }
+	      if ("string" === typeof type) return describeBuiltInComponentFrame(type);
+	      switch (type) {
+	        case REACT_SUSPENSE_TYPE:
+	          return describeBuiltInComponentFrame("Suspense");
+	        case REACT_SUSPENSE_LIST_TYPE:
+	          return describeBuiltInComponentFrame("SuspenseList");
+	      }
+	      if ("object" === typeof type)
+	        switch (type.$$typeof) {
+	          case REACT_FORWARD_REF_TYPE:
+	            return (type = describeNativeComponentFrame(type.render, false)), type;
+	          case REACT_MEMO_TYPE:
+	            return describeUnknownElementTypeFrameInDEV(type.type);
+	          case REACT_LAZY_TYPE:
+	            prototype = type._payload;
+	            type = type._init;
+	            try {
+	              return describeUnknownElementTypeFrameInDEV(type(prototype));
+	            } catch (x) {}
+	        }
+	      return "";
+	    }
+	    function getOwner() {
+	      var dispatcher = ReactSharedInternals.A;
+	      return null === dispatcher ? null : dispatcher.getOwner();
+	    }
+	    function hasValidKey(config) {
+	      if (hasOwnProperty.call(config, "key")) {
+	        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+	        if (getter && getter.isReactWarning) return false;
+	      }
+	      return void 0 !== config.key;
+	    }
+	    function defineKeyPropWarningGetter(props, displayName) {
+	      function warnAboutAccessingKey() {
+	        specialPropKeyWarningShown ||
+	          ((specialPropKeyWarningShown = true),
+	          console.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://react.dev/link/special-props)",
+	            displayName
+	          ));
+	      }
+	      warnAboutAccessingKey.isReactWarning = true;
+	      Object.defineProperty(props, "key", {
+	        get: warnAboutAccessingKey,
+	        configurable: true
+	      });
+	    }
+	    function elementRefGetterWithDeprecationWarning() {
+	      var componentName = getComponentNameFromType(this.type);
+	      didWarnAboutElementRef[componentName] ||
+	        ((didWarnAboutElementRef[componentName] = true),
+	        console.error(
+	          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+	        ));
+	      componentName = this.props.ref;
+	      return void 0 !== componentName ? componentName : null;
+	    }
+	    function ReactElement(type, key, self, source, owner, props) {
+	      self = props.ref;
+	      type = {
+	        $$typeof: REACT_ELEMENT_TYPE,
+	        type: type,
+	        key: key,
+	        props: props,
+	        _owner: owner
+	      };
+	      null !== (void 0 !== self ? self : null)
+	        ? Object.defineProperty(type, "ref", {
+	            enumerable: false,
+	            get: elementRefGetterWithDeprecationWarning
+	          })
+	        : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+	      type._store = {};
+	      Object.defineProperty(type._store, "validated", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: 0
+	      });
+	      Object.defineProperty(type, "_debugInfo", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: null
+	      });
+	      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+	      return type;
+	    }
+	    function jsxDEVImpl(
+	      type,
+	      config,
+	      maybeKey,
+	      isStaticChildren,
+	      source,
+	      self
+	    ) {
+	      if (
+	        "string" === typeof type ||
+	        "function" === typeof type ||
+	        type === REACT_FRAGMENT_TYPE ||
+	        type === REACT_PROFILER_TYPE ||
+	        type === REACT_STRICT_MODE_TYPE ||
+	        type === REACT_SUSPENSE_TYPE ||
+	        type === REACT_SUSPENSE_LIST_TYPE ||
+	        type === REACT_OFFSCREEN_TYPE ||
+	        ("object" === typeof type &&
+	          null !== type &&
+	          (type.$$typeof === REACT_LAZY_TYPE ||
+	            type.$$typeof === REACT_MEMO_TYPE ||
+	            type.$$typeof === REACT_CONTEXT_TYPE ||
+	            type.$$typeof === REACT_CONSUMER_TYPE ||
+	            type.$$typeof === REACT_FORWARD_REF_TYPE ||
+	            type.$$typeof === REACT_CLIENT_REFERENCE$1 ||
+	            void 0 !== type.getModuleId))
+	      ) {
+	        var children = config.children;
+	        if (void 0 !== children)
+	          if (isStaticChildren)
+	            if (isArrayImpl(children)) {
+	              for (
+	                isStaticChildren = 0;
+	                isStaticChildren < children.length;
+	                isStaticChildren++
+	              )
+	                validateChildKeys(children[isStaticChildren], type);
+	              Object.freeze && Object.freeze(children);
+	            } else
+	              console.error(
+	                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+	              );
+	          else validateChildKeys(children, type);
+	      } else {
+	        children = "";
+	        if (
+	          void 0 === type ||
+	          ("object" === typeof type &&
+	            null !== type &&
+	            0 === Object.keys(type).length)
+	        )
+	          children +=
+	            " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
+	        null === type
+	          ? (isStaticChildren = "null")
+	          : isArrayImpl(type)
+	            ? (isStaticChildren = "array")
+	            : void 0 !== type && type.$$typeof === REACT_ELEMENT_TYPE
+	              ? ((isStaticChildren =
+	                  "<" +
+	                  (getComponentNameFromType(type.type) || "Unknown") +
+	                  " />"),
+	                (children =
+	                  " Did you accidentally export a JSX literal instead of a component?"))
+	              : (isStaticChildren = typeof type);
+	        console.error(
+	          "React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s",
+	          isStaticChildren,
+	          children
+	        );
+	      }
+	      if (hasOwnProperty.call(config, "key")) {
+	        children = getComponentNameFromType(type);
+	        var keys = Object.keys(config).filter(function (k) {
+	          return "key" !== k;
+	        });
+	        isStaticChildren =
+	          0 < keys.length
+	            ? "{key: someKey, " + keys.join(": ..., ") + ": ...}"
+	            : "{key: someKey}";
+	        didWarnAboutKeySpread[children + isStaticChildren] ||
+	          ((keys =
+	            0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}"),
+	          console.error(
+	            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+	            isStaticChildren,
+	            children,
+	            keys,
+	            children
+	          ),
+	          (didWarnAboutKeySpread[children + isStaticChildren] = true));
+	      }
+	      children = null;
+	      void 0 !== maybeKey &&
+	        (checkKeyStringCoercion(maybeKey), (children = "" + maybeKey));
+	      hasValidKey(config) &&
+	        (checkKeyStringCoercion(config.key), (children = "" + config.key));
+	      if ("key" in config) {
+	        maybeKey = {};
+	        for (var propName in config)
+	          "key" !== propName && (maybeKey[propName] = config[propName]);
+	      } else maybeKey = config;
+	      children &&
+	        defineKeyPropWarningGetter(
+	          maybeKey,
+	          "function" === typeof type
+	            ? type.displayName || type.name || "Unknown"
+	            : type
+	        );
+	      return ReactElement(type, children, self, source, getOwner(), maybeKey);
+	    }
+	    function validateChildKeys(node, parentType) {
+	      if (
+	        "object" === typeof node &&
+	        node &&
+	        node.$$typeof !== REACT_CLIENT_REFERENCE
+	      )
+	        if (isArrayImpl(node))
+	          for (var i = 0; i < node.length; i++) {
+	            var child = node[i];
+	            isValidElement(child) && validateExplicitKey(child, parentType);
+	          }
+	        else if (isValidElement(node))
+	          node._store && (node._store.validated = 1);
+	        else if (
+	          (null === node || "object" !== typeof node
+	            ? (i = null)
+	            : ((i =
+	                (MAYBE_ITERATOR_SYMBOL && node[MAYBE_ITERATOR_SYMBOL]) ||
+	                node["@@iterator"]),
+	              (i = "function" === typeof i ? i : null)),
+	          "function" === typeof i &&
+	            i !== node.entries &&
+	            ((i = i.call(node)), i !== node))
+	        )
+	          for (; !(node = i.next()).done; )
+	            isValidElement(node.value) &&
+	              validateExplicitKey(node.value, parentType);
+	    }
+	    function isValidElement(object) {
+	      return (
+	        "object" === typeof object &&
+	        null !== object &&
+	        object.$$typeof === REACT_ELEMENT_TYPE
+	      );
+	    }
+	    function validateExplicitKey(element, parentType) {
+	      if (
+	        element._store &&
+	        !element._store.validated &&
+	        null == element.key &&
+	        ((element._store.validated = 1),
+	        (parentType = getCurrentComponentErrorInfo(parentType)),
+	        !ownerHasKeyUseWarning[parentType])
+	      ) {
+	        ownerHasKeyUseWarning[parentType] = true;
+	        var childOwner = "";
+	        element &&
+	          null != element._owner &&
+	          element._owner !== getOwner() &&
+	          ((childOwner = null),
+	          "number" === typeof element._owner.tag
+	            ? (childOwner = getComponentNameFromType(element._owner.type))
+	            : "string" === typeof element._owner.name &&
+	              (childOwner = element._owner.name),
+	          (childOwner = " It was passed a child from " + childOwner + "."));
+	        var prevGetCurrentStack = ReactSharedInternals.getCurrentStack;
+	        ReactSharedInternals.getCurrentStack = function () {
+	          var stack = describeUnknownElementTypeFrameInDEV(element.type);
+	          prevGetCurrentStack && (stack += prevGetCurrentStack() || "");
+	          return stack;
+	        };
+	        console.error(
+	          'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
+	          parentType,
+	          childOwner
+	        );
+	        ReactSharedInternals.getCurrentStack = prevGetCurrentStack;
+	      }
+	    }
+	    function getCurrentComponentErrorInfo(parentType) {
+	      var info = "",
+	        owner = getOwner();
+	      owner &&
+	        (owner = getComponentNameFromType(owner.type)) &&
+	        (info = "\n\nCheck the render method of `" + owner + "`.");
+	      info ||
+	        ((parentType = getComponentNameFromType(parentType)) &&
+	          (info =
+	            "\n\nCheck the top-level render call using <" + parentType + ">."));
+	      return info;
+	    }
+	    var React = React__default,
+	      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+	      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+	      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+	      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+	      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+	    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+	      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+	      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+	      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+	      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+	      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+	      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+	      REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
+	      MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
+	      REACT_CLIENT_REFERENCE$2 = Symbol.for("react.client.reference"),
+	      ReactSharedInternals =
+	        React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+	      hasOwnProperty = Object.prototype.hasOwnProperty,
+	      assign = Object.assign,
+	      REACT_CLIENT_REFERENCE$1 = Symbol.for("react.client.reference"),
+	      isArrayImpl = Array.isArray,
+	      disabledDepth = 0,
+	      prevLog,
+	      prevInfo,
+	      prevWarn,
+	      prevError,
+	      prevGroup,
+	      prevGroupCollapsed,
+	      prevGroupEnd;
+	    disabledLog.__reactDisabledLog = true;
+	    var prefix,
+	      suffix,
+	      reentry = false;
+	    var componentFrameCache = new (
+	      "function" === typeof WeakMap ? WeakMap : Map
+	    )();
+	    var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+	      specialPropKeyWarningShown;
+	    var didWarnAboutElementRef = {};
+	    var didWarnAboutKeySpread = {},
+	      ownerHasKeyUseWarning = {};
+	    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+	    reactJsxRuntime_development.jsx = function (type, config, maybeKey, source, self) {
+	      return jsxDEVImpl(type, config, maybeKey, false, source, self);
+	    };
+	    reactJsxRuntime_development.jsxs = function (type, config, maybeKey, source, self) {
+	      return jsxDEVImpl(type, config, maybeKey, true, source, self);
+	    };
+	  })();
+	return reactJsxRuntime_development;
+}
+
+export { requireReactJsxRuntime_development as __require };
+//# sourceMappingURL=react-jsx-runtime.development.js.map