[Summary view] [Print] [Text view]

   1  /* React JSX Runtime - https://react.dev/ */
   2  
   3  "use strict";
   4  var ReactJSXRuntime = (() => {
   5    var __getOwnPropNames = Object.getOwnPropertyNames;
   6    var __commonJS = (cb, mod) => function __require() {
   7      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   8    };
   9  
  10    // react-global:react
  11    var require_react = __commonJS({
  12      "react-global:react"(exports, module) {
  13        module.exports = window.React;
  14      }
  15    });
  16  
  17    // node_modules/react/cjs/react-jsx-runtime.development.js
  18    var require_react_jsx_runtime_development = __commonJS({
  19      "node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
  20        "use strict";
  21        if (true) {
  22          (function() {
  23            "use strict";
  24            var React = require_react();
  25            var REACT_ELEMENT_TYPE = Symbol.for("react.element");
  26            var REACT_PORTAL_TYPE = Symbol.for("react.portal");
  27            var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
  28            var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
  29            var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
  30            var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
  31            var REACT_CONTEXT_TYPE = Symbol.for("react.context");
  32            var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
  33            var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
  34            var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
  35            var REACT_MEMO_TYPE = Symbol.for("react.memo");
  36            var REACT_LAZY_TYPE = Symbol.for("react.lazy");
  37            var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
  38            var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
  39            var FAUX_ITERATOR_SYMBOL = "@@iterator";
  40            function getIteratorFn(maybeIterable) {
  41              if (maybeIterable === null || typeof maybeIterable !== "object") {
  42                return null;
  43              }
  44              var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
  45              if (typeof maybeIterator === "function") {
  46                return maybeIterator;
  47              }
  48              return null;
  49            }
  50            var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  51            function error(format) {
  52              {
  53                {
  54                  for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
  55                    args[_key2 - 1] = arguments[_key2];
  56                  }
  57                  printWarning("error", format, args);
  58                }
  59              }
  60            }
  61            function printWarning(level, format, args) {
  62              {
  63                var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
  64                var stack = ReactDebugCurrentFrame2.getStackAddendum();
  65                if (stack !== "") {
  66                  format += "%s";
  67                  args = args.concat([stack]);
  68                }
  69                var argsWithFormat = args.map(function(item) {
  70                  return String(item);
  71                });
  72                argsWithFormat.unshift("Warning: " + format);
  73                Function.prototype.apply.call(console[level], console, argsWithFormat);
  74              }
  75            }
  76            var enableScopeAPI = false;
  77            var enableCacheElement = false;
  78            var enableTransitionTracing = false;
  79            var enableLegacyHidden = false;
  80            var enableDebugTracing = false;
  81            var REACT_MODULE_REFERENCE;
  82            {
  83              REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
  84            }
  85            function isValidElementType(type) {
  86              if (typeof type === "string" || typeof type === "function") {
  87                return true;
  88              }
  89              if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
  90                return true;
  91              }
  92              if (typeof type === "object" && type !== null) {
  93                if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
  94                // types supported by any Flight configuration anywhere since
  95                // we don't know which Flight build this will end up being used
  96                // with.
  97                type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
  98                  return true;
  99                }
 100              }
 101              return false;
 102            }
 103            function getWrappedName(outerType, innerType, wrapperName) {
 104              var displayName = outerType.displayName;
 105              if (displayName) {
 106                return displayName;
 107              }
 108              var functionName = innerType.displayName || innerType.name || "";
 109              return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
 110            }
 111            function getContextName(type) {
 112              return type.displayName || "Context";
 113            }
 114            function getComponentNameFromType(type) {
 115              if (type == null) {
 116                return null;
 117              }
 118              {
 119                if (typeof type.tag === "number") {
 120                  error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
 121                }
 122              }
 123              if (typeof type === "function") {
 124                return type.displayName || type.name || null;
 125              }
 126              if (typeof type === "string") {
 127                return type;
 128              }
 129              switch (type) {
 130                case REACT_FRAGMENT_TYPE:
 131                  return "Fragment";
 132                case REACT_PORTAL_TYPE:
 133                  return "Portal";
 134                case REACT_PROFILER_TYPE:
 135                  return "Profiler";
 136                case REACT_STRICT_MODE_TYPE:
 137                  return "StrictMode";
 138                case REACT_SUSPENSE_TYPE:
 139                  return "Suspense";
 140                case REACT_SUSPENSE_LIST_TYPE:
 141                  return "SuspenseList";
 142              }
 143              if (typeof type === "object") {
 144                switch (type.$$typeof) {
 145                  case REACT_CONTEXT_TYPE:
 146                    var context = type;
 147                    return getContextName(context) + ".Consumer";
 148                  case REACT_PROVIDER_TYPE:
 149                    var provider = type;
 150                    return getContextName(provider._context) + ".Provider";
 151                  case REACT_FORWARD_REF_TYPE:
 152                    return getWrappedName(type, type.render, "ForwardRef");
 153                  case REACT_MEMO_TYPE:
 154                    var outerName = type.displayName || null;
 155                    if (outerName !== null) {
 156                      return outerName;
 157                    }
 158                    return getComponentNameFromType(type.type) || "Memo";
 159                  case REACT_LAZY_TYPE: {
 160                    var lazyComponent = type;
 161                    var payload = lazyComponent._payload;
 162                    var init = lazyComponent._init;
 163                    try {
 164                      return getComponentNameFromType(init(payload));
 165                    } catch (x) {
 166                      return null;
 167                    }
 168                  }
 169                }
 170              }
 171              return null;
 172            }
 173            var assign = Object.assign;
 174            var disabledDepth = 0;
 175            var prevLog;
 176            var prevInfo;
 177            var prevWarn;
 178            var prevError;
 179            var prevGroup;
 180            var prevGroupCollapsed;
 181            var prevGroupEnd;
 182            function disabledLog() {
 183            }
 184            disabledLog.__reactDisabledLog = true;
 185            function disableLogs() {
 186              {
 187                if (disabledDepth === 0) {
 188                  prevLog = console.log;
 189                  prevInfo = console.info;
 190                  prevWarn = console.warn;
 191                  prevError = console.error;
 192                  prevGroup = console.group;
 193                  prevGroupCollapsed = console.groupCollapsed;
 194                  prevGroupEnd = console.groupEnd;
 195                  var props = {
 196                    configurable: true,
 197                    enumerable: true,
 198                    value: disabledLog,
 199                    writable: true
 200                  };
 201                  Object.defineProperties(console, {
 202                    info: props,
 203                    log: props,
 204                    warn: props,
 205                    error: props,
 206                    group: props,
 207                    groupCollapsed: props,
 208                    groupEnd: props
 209                  });
 210                }
 211                disabledDepth++;
 212              }
 213            }
 214            function reenableLogs() {
 215              {
 216                disabledDepth--;
 217                if (disabledDepth === 0) {
 218                  var props = {
 219                    configurable: true,
 220                    enumerable: true,
 221                    writable: true
 222                  };
 223                  Object.defineProperties(console, {
 224                    log: assign({}, props, {
 225                      value: prevLog
 226                    }),
 227                    info: assign({}, props, {
 228                      value: prevInfo
 229                    }),
 230                    warn: assign({}, props, {
 231                      value: prevWarn
 232                    }),
 233                    error: assign({}, props, {
 234                      value: prevError
 235                    }),
 236                    group: assign({}, props, {
 237                      value: prevGroup
 238                    }),
 239                    groupCollapsed: assign({}, props, {
 240                      value: prevGroupCollapsed
 241                    }),
 242                    groupEnd: assign({}, props, {
 243                      value: prevGroupEnd
 244                    })
 245                  });
 246                }
 247                if (disabledDepth < 0) {
 248                  error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
 249                }
 250              }
 251            }
 252            var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
 253            var prefix;
 254            function describeBuiltInComponentFrame(name, source, ownerFn) {
 255              {
 256                if (prefix === void 0) {
 257                  try {
 258                    throw Error();
 259                  } catch (x) {
 260                    var match = x.stack.trim().match(/\n( *(at )?)/);
 261                    prefix = match && match[1] || "";
 262                  }
 263                }
 264                return "\n" + prefix + name;
 265              }
 266            }
 267            var reentry = false;
 268            var componentFrameCache;
 269            {
 270              var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
 271              componentFrameCache = new PossiblyWeakMap();
 272            }
 273            function describeNativeComponentFrame(fn, construct) {
 274              if (!fn || reentry) {
 275                return "";
 276              }
 277              {
 278                var frame = componentFrameCache.get(fn);
 279                if (frame !== void 0) {
 280                  return frame;
 281                }
 282              }
 283              var control;
 284              reentry = true;
 285              var previousPrepareStackTrace = Error.prepareStackTrace;
 286              Error.prepareStackTrace = void 0;
 287              var previousDispatcher;
 288              {
 289                previousDispatcher = ReactCurrentDispatcher.current;
 290                ReactCurrentDispatcher.current = null;
 291                disableLogs();
 292              }
 293              try {
 294                if (construct) {
 295                  var Fake = function() {
 296                    throw Error();
 297                  };
 298                  Object.defineProperty(Fake.prototype, "props", {
 299                    set: function() {
 300                      throw Error();
 301                    }
 302                  });
 303                  if (typeof Reflect === "object" && Reflect.construct) {
 304                    try {
 305                      Reflect.construct(Fake, []);
 306                    } catch (x) {
 307                      control = x;
 308                    }
 309                    Reflect.construct(fn, [], Fake);
 310                  } else {
 311                    try {
 312                      Fake.call();
 313                    } catch (x) {
 314                      control = x;
 315                    }
 316                    fn.call(Fake.prototype);
 317                  }
 318                } else {
 319                  try {
 320                    throw Error();
 321                  } catch (x) {
 322                    control = x;
 323                  }
 324                  fn();
 325                }
 326              } catch (sample) {
 327                if (sample && control && typeof sample.stack === "string") {
 328                  var sampleLines = sample.stack.split("\n");
 329                  var controlLines = control.stack.split("\n");
 330                  var s = sampleLines.length - 1;
 331                  var c = controlLines.length - 1;
 332                  while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
 333                    c--;
 334                  }
 335                  for (; s >= 1 && c >= 0; s--, c--) {
 336                    if (sampleLines[s] !== controlLines[c]) {
 337                      if (s !== 1 || c !== 1) {
 338                        do {
 339                          s--;
 340                          c--;
 341                          if (c < 0 || sampleLines[s] !== controlLines[c]) {
 342                            var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
 343                            if (fn.displayName && _frame.includes("<anonymous>")) {
 344                              _frame = _frame.replace("<anonymous>", fn.displayName);
 345                            }
 346                            {
 347                              if (typeof fn === "function") {
 348                                componentFrameCache.set(fn, _frame);
 349                              }
 350                            }
 351                            return _frame;
 352                          }
 353                        } while (s >= 1 && c >= 0);
 354                      }
 355                      break;
 356                    }
 357                  }
 358                }
 359              } finally {
 360                reentry = false;
 361                {
 362                  ReactCurrentDispatcher.current = previousDispatcher;
 363                  reenableLogs();
 364                }
 365                Error.prepareStackTrace = previousPrepareStackTrace;
 366              }
 367              var name = fn ? fn.displayName || fn.name : "";
 368              var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
 369              {
 370                if (typeof fn === "function") {
 371                  componentFrameCache.set(fn, syntheticFrame);
 372                }
 373              }
 374              return syntheticFrame;
 375            }
 376            function describeFunctionComponentFrame(fn, source, ownerFn) {
 377              {
 378                return describeNativeComponentFrame(fn, false);
 379              }
 380            }
 381            function shouldConstruct(Component) {
 382              var prototype = Component.prototype;
 383              return !!(prototype && prototype.isReactComponent);
 384            }
 385            function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
 386              if (type == null) {
 387                return "";
 388              }
 389              if (typeof type === "function") {
 390                {
 391                  return describeNativeComponentFrame(type, shouldConstruct(type));
 392                }
 393              }
 394              if (typeof type === "string") {
 395                return describeBuiltInComponentFrame(type);
 396              }
 397              switch (type) {
 398                case REACT_SUSPENSE_TYPE:
 399                  return describeBuiltInComponentFrame("Suspense");
 400                case REACT_SUSPENSE_LIST_TYPE:
 401                  return describeBuiltInComponentFrame("SuspenseList");
 402              }
 403              if (typeof type === "object") {
 404                switch (type.$$typeof) {
 405                  case REACT_FORWARD_REF_TYPE:
 406                    return describeFunctionComponentFrame(type.render);
 407                  case REACT_MEMO_TYPE:
 408                    return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
 409                  case REACT_LAZY_TYPE: {
 410                    var lazyComponent = type;
 411                    var payload = lazyComponent._payload;
 412                    var init = lazyComponent._init;
 413                    try {
 414                      return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
 415                    } catch (x) {
 416                    }
 417                  }
 418                }
 419              }
 420              return "";
 421            }
 422            var hasOwnProperty = Object.prototype.hasOwnProperty;
 423            var loggedTypeFailures = {};
 424            var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
 425            function setCurrentlyValidatingElement(element) {
 426              {
 427                if (element) {
 428                  var owner = element._owner;
 429                  var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
 430                  ReactDebugCurrentFrame.setExtraStackFrame(stack);
 431                } else {
 432                  ReactDebugCurrentFrame.setExtraStackFrame(null);
 433                }
 434              }
 435            }
 436            function checkPropTypes(typeSpecs, values, location, componentName, element) {
 437              {
 438                var has = Function.call.bind(hasOwnProperty);
 439                for (var typeSpecName in typeSpecs) {
 440                  if (has(typeSpecs, typeSpecName)) {
 441                    var error$1 = void 0;
 442                    try {
 443                      if (typeof typeSpecs[typeSpecName] !== "function") {
 444                        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`.");
 445                        err.name = "Invariant Violation";
 446                        throw err;
 447                      }
 448                      error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
 449                    } catch (ex) {
 450                      error$1 = ex;
 451                    }
 452                    if (error$1 && !(error$1 instanceof Error)) {
 453                      setCurrentlyValidatingElement(element);
 454                      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);
 455                      setCurrentlyValidatingElement(null);
 456                    }
 457                    if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
 458                      loggedTypeFailures[error$1.message] = true;
 459                      setCurrentlyValidatingElement(element);
 460                      error("Failed %s type: %s", location, error$1.message);
 461                      setCurrentlyValidatingElement(null);
 462                    }
 463                  }
 464                }
 465              }
 466            }
 467            var isArrayImpl = Array.isArray;
 468            function isArray(a) {
 469              return isArrayImpl(a);
 470            }
 471            function typeName(value) {
 472              {
 473                var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
 474                var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
 475                return type;
 476              }
 477            }
 478            function willCoercionThrow(value) {
 479              {
 480                try {
 481                  testStringCoercion(value);
 482                  return false;
 483                } catch (e) {
 484                  return true;
 485                }
 486              }
 487            }
 488            function testStringCoercion(value) {
 489              return "" + value;
 490            }
 491            function checkKeyStringCoercion(value) {
 492              {
 493                if (willCoercionThrow(value)) {
 494                  error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
 495                  return testStringCoercion(value);
 496                }
 497              }
 498            }
 499            var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
 500            var RESERVED_PROPS = {
 501              key: true,
 502              ref: true,
 503              __self: true,
 504              __source: true
 505            };
 506            var specialPropKeyWarningShown;
 507            var specialPropRefWarningShown;
 508            var didWarnAboutStringRefs;
 509            {
 510              didWarnAboutStringRefs = {};
 511            }
 512            function hasValidRef(config) {
 513              {
 514                if (hasOwnProperty.call(config, "ref")) {
 515                  var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
 516                  if (getter && getter.isReactWarning) {
 517                    return false;
 518                  }
 519                }
 520              }
 521              return config.ref !== void 0;
 522            }
 523            function hasValidKey(config) {
 524              {
 525                if (hasOwnProperty.call(config, "key")) {
 526                  var getter = Object.getOwnPropertyDescriptor(config, "key").get;
 527                  if (getter && getter.isReactWarning) {
 528                    return false;
 529                  }
 530                }
 531              }
 532              return config.key !== void 0;
 533            }
 534            function warnIfStringRefCannotBeAutoConverted(config, self) {
 535              {
 536                if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
 537                  var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
 538                  if (!didWarnAboutStringRefs[componentName]) {
 539                    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', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
 540                    didWarnAboutStringRefs[componentName] = true;
 541                  }
 542                }
 543              }
 544            }
 545            function defineKeyPropWarningGetter(props, displayName) {
 546              {
 547                var warnAboutAccessingKey = function() {
 548                  if (!specialPropKeyWarningShown) {
 549                    specialPropKeyWarningShown = true;
 550                    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);
 551                  }
 552                };
 553                warnAboutAccessingKey.isReactWarning = true;
 554                Object.defineProperty(props, "key", {
 555                  get: warnAboutAccessingKey,
 556                  configurable: true
 557                });
 558              }
 559            }
 560            function defineRefPropWarningGetter(props, displayName) {
 561              {
 562                var warnAboutAccessingRef = function() {
 563                  if (!specialPropRefWarningShown) {
 564                    specialPropRefWarningShown = true;
 565                    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);
 566                  }
 567                };
 568                warnAboutAccessingRef.isReactWarning = true;
 569                Object.defineProperty(props, "ref", {
 570                  get: warnAboutAccessingRef,
 571                  configurable: true
 572                });
 573              }
 574            }
 575            var ReactElement = function(type, key, ref, self, source, owner, props) {
 576              var element = {
 577                // This tag allows us to uniquely identify this as a React Element
 578                $$typeof: REACT_ELEMENT_TYPE,
 579                // Built-in properties that belong on the element
 580                type,
 581                key,
 582                ref,
 583                props,
 584                // Record the component responsible for creating this element.
 585                _owner: owner
 586              };
 587              {
 588                element._store = {};
 589                Object.defineProperty(element._store, "validated", {
 590                  configurable: false,
 591                  enumerable: false,
 592                  writable: true,
 593                  value: false
 594                });
 595                Object.defineProperty(element, "_self", {
 596                  configurable: false,
 597                  enumerable: false,
 598                  writable: false,
 599                  value: self
 600                });
 601                Object.defineProperty(element, "_source", {
 602                  configurable: false,
 603                  enumerable: false,
 604                  writable: false,
 605                  value: source
 606                });
 607                if (Object.freeze) {
 608                  Object.freeze(element.props);
 609                  Object.freeze(element);
 610                }
 611              }
 612              return element;
 613            };
 614            function jsxDEV(type, config, maybeKey, source, self) {
 615              {
 616                var propName;
 617                var props = {};
 618                var key = null;
 619                var ref = null;
 620                if (maybeKey !== void 0) {
 621                  {
 622                    checkKeyStringCoercion(maybeKey);
 623                  }
 624                  key = "" + maybeKey;
 625                }
 626                if (hasValidKey(config)) {
 627                  {
 628                    checkKeyStringCoercion(config.key);
 629                  }
 630                  key = "" + config.key;
 631                }
 632                if (hasValidRef(config)) {
 633                  ref = config.ref;
 634                  warnIfStringRefCannotBeAutoConverted(config, self);
 635                }
 636                for (propName in config) {
 637                  if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
 638                    props[propName] = config[propName];
 639                  }
 640                }
 641                if (type && type.defaultProps) {
 642                  var defaultProps = type.defaultProps;
 643                  for (propName in defaultProps) {
 644                    if (props[propName] === void 0) {
 645                      props[propName] = defaultProps[propName];
 646                    }
 647                  }
 648                }
 649                if (key || ref) {
 650                  var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
 651                  if (key) {
 652                    defineKeyPropWarningGetter(props, displayName);
 653                  }
 654                  if (ref) {
 655                    defineRefPropWarningGetter(props, displayName);
 656                  }
 657                }
 658                return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
 659              }
 660            }
 661            var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
 662            var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
 663            function setCurrentlyValidatingElement$1(element) {
 664              {
 665                if (element) {
 666                  var owner = element._owner;
 667                  var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
 668                  ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
 669                } else {
 670                  ReactDebugCurrentFrame$1.setExtraStackFrame(null);
 671                }
 672              }
 673            }
 674            var propTypesMisspellWarningShown;
 675            {
 676              propTypesMisspellWarningShown = false;
 677            }
 678            function isValidElement(object) {
 679              {
 680                return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
 681              }
 682            }
 683            function getDeclarationErrorAddendum() {
 684              {
 685                if (ReactCurrentOwner$1.current) {
 686                  var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
 687                  if (name) {
 688                    return "\n\nCheck the render method of `" + name + "`.";
 689                  }
 690                }
 691                return "";
 692              }
 693            }
 694            function getSourceInfoErrorAddendum(source) {
 695              {
 696                if (source !== void 0) {
 697                  var fileName = source.fileName.replace(/^.*[\\\/]/, "");
 698                  var lineNumber = source.lineNumber;
 699                  return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
 700                }
 701                return "";
 702              }
 703            }
 704            var ownerHasKeyUseWarning = {};
 705            function getCurrentComponentErrorInfo(parentType) {
 706              {
 707                var info = getDeclarationErrorAddendum();
 708                if (!info) {
 709                  var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
 710                  if (parentName) {
 711                    info = "\n\nCheck the top-level render call using <" + parentName + ">.";
 712                  }
 713                }
 714                return info;
 715              }
 716            }
 717            function validateExplicitKey(element, parentType) {
 718              {
 719                if (!element._store || element._store.validated || element.key != null) {
 720                  return;
 721                }
 722                element._store.validated = true;
 723                var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
 724                if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
 725                  return;
 726                }
 727                ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
 728                var childOwner = "";
 729                if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
 730                  childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
 731                }
 732                setCurrentlyValidatingElement$1(element);
 733                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);
 734                setCurrentlyValidatingElement$1(null);
 735              }
 736            }
 737            function validateChildKeys(node, parentType) {
 738              {
 739                if (typeof node !== "object") {
 740                  return;
 741                }
 742                if (isArray(node)) {
 743                  for (var i = 0; i < node.length; i++) {
 744                    var child = node[i];
 745                    if (isValidElement(child)) {
 746                      validateExplicitKey(child, parentType);
 747                    }
 748                  }
 749                } else if (isValidElement(node)) {
 750                  if (node._store) {
 751                    node._store.validated = true;
 752                  }
 753                } else if (node) {
 754                  var iteratorFn = getIteratorFn(node);
 755                  if (typeof iteratorFn === "function") {
 756                    if (iteratorFn !== node.entries) {
 757                      var iterator = iteratorFn.call(node);
 758                      var step;
 759                      while (!(step = iterator.next()).done) {
 760                        if (isValidElement(step.value)) {
 761                          validateExplicitKey(step.value, parentType);
 762                        }
 763                      }
 764                    }
 765                  }
 766                }
 767              }
 768            }
 769            function validatePropTypes(element) {
 770              {
 771                var type = element.type;
 772                if (type === null || type === void 0 || typeof type === "string") {
 773                  return;
 774                }
 775                var propTypes;
 776                if (typeof type === "function") {
 777                  propTypes = type.propTypes;
 778                } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
 779                // Inner props are checked in the reconciler.
 780                type.$$typeof === REACT_MEMO_TYPE)) {
 781                  propTypes = type.propTypes;
 782                } else {
 783                  return;
 784                }
 785                if (propTypes) {
 786                  var name = getComponentNameFromType(type);
 787                  checkPropTypes(propTypes, element.props, "prop", name, element);
 788                } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
 789                  propTypesMisspellWarningShown = true;
 790                  var _name = getComponentNameFromType(type);
 791                  error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
 792                }
 793                if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
 794                  error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
 795                }
 796              }
 797            }
 798            function validateFragmentProps(fragment) {
 799              {
 800                var keys = Object.keys(fragment.props);
 801                for (var i = 0; i < keys.length; i++) {
 802                  var key = keys[i];
 803                  if (key !== "children" && key !== "key") {
 804                    setCurrentlyValidatingElement$1(fragment);
 805                    error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
 806                    setCurrentlyValidatingElement$1(null);
 807                    break;
 808                  }
 809                }
 810                if (fragment.ref !== null) {
 811                  setCurrentlyValidatingElement$1(fragment);
 812                  error("Invalid attribute `ref` supplied to `React.Fragment`.");
 813                  setCurrentlyValidatingElement$1(null);
 814                }
 815              }
 816            }
 817            var didWarnAboutKeySpread = {};
 818            function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
 819              {
 820                var validType = isValidElementType(type);
 821                if (!validType) {
 822                  var info = "";
 823                  if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
 824                    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.";
 825                  }
 826                  var sourceInfo = getSourceInfoErrorAddendum(source);
 827                  if (sourceInfo) {
 828                    info += sourceInfo;
 829                  } else {
 830                    info += getDeclarationErrorAddendum();
 831                  }
 832                  var typeString;
 833                  if (type === null) {
 834                    typeString = "null";
 835                  } else if (isArray(type)) {
 836                    typeString = "array";
 837                  } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
 838                    typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
 839                    info = " Did you accidentally export a JSX literal instead of a component?";
 840                  } else {
 841                    typeString = typeof type;
 842                  }
 843                  error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
 844                }
 845                var element = jsxDEV(type, props, key, source, self);
 846                if (element == null) {
 847                  return element;
 848                }
 849                if (validType) {
 850                  var children = props.children;
 851                  if (children !== void 0) {
 852                    if (isStaticChildren) {
 853                      if (isArray(children)) {
 854                        for (var i = 0; i < children.length; i++) {
 855                          validateChildKeys(children[i], type);
 856                        }
 857                        if (Object.freeze) {
 858                          Object.freeze(children);
 859                        }
 860                      } else {
 861                        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.");
 862                      }
 863                    } else {
 864                      validateChildKeys(children, type);
 865                    }
 866                  }
 867                }
 868                {
 869                  if (hasOwnProperty.call(props, "key")) {
 870                    var componentName = getComponentNameFromType(type);
 871                    var keys = Object.keys(props).filter(function(k) {
 872                      return k !== "key";
 873                    });
 874                    var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
 875                    if (!didWarnAboutKeySpread[componentName + beforeExample]) {
 876                      var afterExample = keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}";
 877                      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} />', beforeExample, componentName, afterExample, componentName);
 878                      didWarnAboutKeySpread[componentName + beforeExample] = true;
 879                    }
 880                  }
 881                }
 882                if (type === REACT_FRAGMENT_TYPE) {
 883                  validateFragmentProps(element);
 884                } else {
 885                  validatePropTypes(element);
 886                }
 887                return element;
 888              }
 889            }
 890            function jsxWithValidationStatic(type, props, key) {
 891              {
 892                return jsxWithValidation(type, props, key, true);
 893              }
 894            }
 895            function jsxWithValidationDynamic(type, props, key) {
 896              {
 897                return jsxWithValidation(type, props, key, false);
 898              }
 899            }
 900            var jsx = jsxWithValidationDynamic;
 901            var jsxs = jsxWithValidationStatic;
 902            exports.Fragment = REACT_FRAGMENT_TYPE;
 903            exports.jsx = jsx;
 904            exports.jsxs = jsxs;
 905          })();
 906        }
 907      }
 908    });
 909  
 910    // node_modules/react/jsx-runtime.js
 911    var require_jsx_runtime = __commonJS({
 912      "node_modules/react/jsx-runtime.js"(exports, module) {
 913        if (false) {
 914          module.exports = null;
 915        } else {
 916          module.exports = require_react_jsx_runtime_development();
 917        }
 918      }
 919    });
 920    return require_jsx_runtime();
 921  })();
 922  /*! Bundled license information:
 923  
 924  react/cjs/react-jsx-runtime.development.js:
 925    (**
 926     * @license React
 927     * react-jsx-runtime.development.js
 928     *
 929     * Copyright (c) Facebook, Inc. and its affiliates.
 930     *
 931     * This source code is licensed under the MIT license found in the
 932     * LICENSE file in the root directory of this source tree.
 933     *)
 934  */