[Summary view] [Print] [Text view]

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