[Summary view] [Print] [Text view]

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