Mercurial

comparison react_games/public/games/chunk-AX5M7HF6.js @ 37:fb9bcd3145cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ReactGames] Few games I made using react just to practice few things.
author MrJuneJune <me@mrjunejune.com>
date Mon, 01 Dec 2025 20:22:47 -0800
parents
children
comparison
equal deleted inserted replaced
36:84672efec192 37:fb9bcd3145cb
1 var __create = Object.create;
2 var __defProp = Object.defineProperty;
3 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4 var __getOwnPropNames = Object.getOwnPropertyNames;
5 var __getProtoOf = Object.getPrototypeOf;
6 var __hasOwnProp = Object.prototype.hasOwnProperty;
7 var __commonJS = (cb, mod) => function __require() {
8 return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
9 };
10 var __copyProps = (to, from, except, desc) => {
11 if (from && typeof from === "object" || typeof from === "function") {
12 for (let key of __getOwnPropNames(from))
13 if (!__hasOwnProp.call(to, key) && key !== except)
14 __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15 }
16 return to;
17 };
18 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
19 // If the importer is in node compatibility mode or this is not an ESM
20 // file that has been converted to a CommonJS file using a Babel-
21 // compatible transform (i.e. "__esModule" has not been set), then set
22 // "default" to the CommonJS "module.exports" for node compatibility.
23 isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
24 mod
25 ));
26
27 // node_modules/react/cjs/react.development.js
28 var require_react_development = __commonJS({
29 "node_modules/react/cjs/react.development.js"(exports, module) {
30 "use strict";
31 (function() {
32 function defineDeprecationWarning(methodName, info) {
33 Object.defineProperty(Component.prototype, methodName, {
34 get: function() {
35 console.warn(
36 "%s(...) is deprecated in plain JavaScript React classes. %s",
37 info[0],
38 info[1]
39 );
40 }
41 });
42 }
43 function getIteratorFn(maybeIterable) {
44 if (null === maybeIterable || "object" !== typeof maybeIterable)
45 return null;
46 maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
47 return "function" === typeof maybeIterable ? maybeIterable : null;
48 }
49 function warnNoop(publicInstance, callerName) {
50 publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
51 var warningKey = publicInstance + "." + callerName;
52 didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error(
53 "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
54 callerName,
55 publicInstance
56 ), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
57 }
58 function Component(props, context, updater) {
59 this.props = props;
60 this.context = context;
61 this.refs = emptyObject;
62 this.updater = updater || ReactNoopUpdateQueue;
63 }
64 function ComponentDummy() {
65 }
66 function PureComponent(props, context, updater) {
67 this.props = props;
68 this.context = context;
69 this.refs = emptyObject;
70 this.updater = updater || ReactNoopUpdateQueue;
71 }
72 function testStringCoercion(value) {
73 return "" + value;
74 }
75 function checkKeyStringCoercion(value) {
76 try {
77 testStringCoercion(value);
78 var JSCompiler_inline_result = false;
79 } catch (e) {
80 JSCompiler_inline_result = true;
81 }
82 if (JSCompiler_inline_result) {
83 JSCompiler_inline_result = console;
84 var JSCompiler_temp_const = JSCompiler_inline_result.error;
85 var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
86 JSCompiler_temp_const.call(
87 JSCompiler_inline_result,
88 "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
89 JSCompiler_inline_result$jscomp$0
90 );
91 return testStringCoercion(value);
92 }
93 }
94 function getComponentNameFromType(type) {
95 if (null == type) return null;
96 if ("function" === typeof type)
97 return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
98 if ("string" === typeof type) return type;
99 switch (type) {
100 case REACT_FRAGMENT_TYPE:
101 return "Fragment";
102 case REACT_PROFILER_TYPE:
103 return "Profiler";
104 case REACT_STRICT_MODE_TYPE:
105 return "StrictMode";
106 case REACT_SUSPENSE_TYPE:
107 return "Suspense";
108 case REACT_SUSPENSE_LIST_TYPE:
109 return "SuspenseList";
110 case REACT_ACTIVITY_TYPE:
111 return "Activity";
112 }
113 if ("object" === typeof type)
114 switch ("number" === typeof type.tag && console.error(
115 "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
116 ), type.$$typeof) {
117 case REACT_PORTAL_TYPE:
118 return "Portal";
119 case REACT_CONTEXT_TYPE:
120 return (type.displayName || "Context") + ".Provider";
121 case REACT_CONSUMER_TYPE:
122 return (type._context.displayName || "Context") + ".Consumer";
123 case REACT_FORWARD_REF_TYPE:
124 var innerType = type.render;
125 type = type.displayName;
126 type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
127 return type;
128 case REACT_MEMO_TYPE:
129 return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
130 case REACT_LAZY_TYPE:
131 innerType = type._payload;
132 type = type._init;
133 try {
134 return getComponentNameFromType(type(innerType));
135 } catch (x) {
136 }
137 }
138 return null;
139 }
140 function getTaskName(type) {
141 if (type === REACT_FRAGMENT_TYPE) return "<>";
142 if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
143 return "<...>";
144 try {
145 var name = getComponentNameFromType(type);
146 return name ? "<" + name + ">" : "<...>";
147 } catch (x) {
148 return "<...>";
149 }
150 }
151 function getOwner() {
152 var dispatcher = ReactSharedInternals.A;
153 return null === dispatcher ? null : dispatcher.getOwner();
154 }
155 function UnknownOwner() {
156 return Error("react-stack-top-frame");
157 }
158 function hasValidKey(config) {
159 if (hasOwnProperty.call(config, "key")) {
160 var getter = Object.getOwnPropertyDescriptor(config, "key").get;
161 if (getter && getter.isReactWarning) return false;
162 }
163 return void 0 !== config.key;
164 }
165 function defineKeyPropWarningGetter(props, displayName) {
166 function warnAboutAccessingKey() {
167 specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
168 "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
169 displayName
170 ));
171 }
172 warnAboutAccessingKey.isReactWarning = true;
173 Object.defineProperty(props, "key", {
174 get: warnAboutAccessingKey,
175 configurable: true
176 });
177 }
178 function elementRefGetterWithDeprecationWarning() {
179 var componentName = getComponentNameFromType(this.type);
180 didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
181 "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
182 ));
183 componentName = this.props.ref;
184 return void 0 !== componentName ? componentName : null;
185 }
186 function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
187 self = props.ref;
188 type = {
189 $$typeof: REACT_ELEMENT_TYPE,
190 type,
191 key,
192 props,
193 _owner: owner
194 };
195 null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
196 enumerable: false,
197 get: elementRefGetterWithDeprecationWarning
198 }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
199 type._store = {};
200 Object.defineProperty(type._store, "validated", {
201 configurable: false,
202 enumerable: false,
203 writable: true,
204 value: 0
205 });
206 Object.defineProperty(type, "_debugInfo", {
207 configurable: false,
208 enumerable: false,
209 writable: true,
210 value: null
211 });
212 Object.defineProperty(type, "_debugStack", {
213 configurable: false,
214 enumerable: false,
215 writable: true,
216 value: debugStack
217 });
218 Object.defineProperty(type, "_debugTask", {
219 configurable: false,
220 enumerable: false,
221 writable: true,
222 value: debugTask
223 });
224 Object.freeze && (Object.freeze(type.props), Object.freeze(type));
225 return type;
226 }
227 function cloneAndReplaceKey(oldElement, newKey) {
228 newKey = ReactElement(
229 oldElement.type,
230 newKey,
231 void 0,
232 void 0,
233 oldElement._owner,
234 oldElement.props,
235 oldElement._debugStack,
236 oldElement._debugTask
237 );
238 oldElement._store && (newKey._store.validated = oldElement._store.validated);
239 return newKey;
240 }
241 function isValidElement(object) {
242 return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
243 }
244 function escape(key) {
245 var escaperLookup = { "=": "=0", ":": "=2" };
246 return "$" + key.replace(/[=:]/g, function(match) {
247 return escaperLookup[match];
248 });
249 }
250 function getElementKey(element, index) {
251 return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
252 }
253 function noop$1() {
254 }
255 function resolveThenable(thenable) {
256 switch (thenable.status) {
257 case "fulfilled":
258 return thenable.value;
259 case "rejected":
260 throw thenable.reason;
261 default:
262 switch ("string" === typeof thenable.status ? thenable.then(noop$1, noop$1) : (thenable.status = "pending", thenable.then(
263 function(fulfilledValue) {
264 "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
265 },
266 function(error) {
267 "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
268 }
269 )), thenable.status) {
270 case "fulfilled":
271 return thenable.value;
272 case "rejected":
273 throw thenable.reason;
274 }
275 }
276 throw thenable;
277 }
278 function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
279 var type = typeof children;
280 if ("undefined" === type || "boolean" === type) children = null;
281 var invokeCallback = false;
282 if (null === children) invokeCallback = true;
283 else
284 switch (type) {
285 case "bigint":
286 case "string":
287 case "number":
288 invokeCallback = true;
289 break;
290 case "object":
291 switch (children.$$typeof) {
292 case REACT_ELEMENT_TYPE:
293 case REACT_PORTAL_TYPE:
294 invokeCallback = true;
295 break;
296 case REACT_LAZY_TYPE:
297 return invokeCallback = children._init, mapIntoArray(
298 invokeCallback(children._payload),
299 array,
300 escapedPrefix,
301 nameSoFar,
302 callback
303 );
304 }
305 }
306 if (invokeCallback) {
307 invokeCallback = children;
308 callback = callback(invokeCallback);
309 var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
310 isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
311 return c;
312 })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(
313 callback,
314 escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(
315 userProvidedKeyEscapeRegex,
316 "$&/"
317 ) + "/") + childKey
318 ), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
319 return 1;
320 }
321 invokeCallback = 0;
322 childKey = "" === nameSoFar ? "." : nameSoFar + ":";
323 if (isArrayImpl(children))
324 for (var i = 0; i < children.length; i++)
325 nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
326 nameSoFar,
327 array,
328 escapedPrefix,
329 type,
330 callback
331 );
332 else if (i = getIteratorFn(children), "function" === typeof i)
333 for (i === children.entries && (didWarnAboutMaps || console.warn(
334 "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
335 ), didWarnAboutMaps = true), children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
336 nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
337 nameSoFar,
338 array,
339 escapedPrefix,
340 type,
341 callback
342 );
343 else if ("object" === type) {
344 if ("function" === typeof children.then)
345 return mapIntoArray(
346 resolveThenable(children),
347 array,
348 escapedPrefix,
349 nameSoFar,
350 callback
351 );
352 array = String(children);
353 throw Error(
354 "Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
355 );
356 }
357 return invokeCallback;
358 }
359 function mapChildren(children, func, context) {
360 if (null == children) return children;
361 var result = [], count = 0;
362 mapIntoArray(children, result, "", "", function(child) {
363 return func.call(context, child, count++);
364 });
365 return result;
366 }
367 function lazyInitializer(payload) {
368 if (-1 === payload._status) {
369 var ctor = payload._result;
370 ctor = ctor();
371 ctor.then(
372 function(moduleObject) {
373 if (0 === payload._status || -1 === payload._status)
374 payload._status = 1, payload._result = moduleObject;
375 },
376 function(error) {
377 if (0 === payload._status || -1 === payload._status)
378 payload._status = 2, payload._result = error;
379 }
380 );
381 -1 === payload._status && (payload._status = 0, payload._result = ctor);
382 }
383 if (1 === payload._status)
384 return ctor = payload._result, void 0 === ctor && console.error(
385 "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?",
386 ctor
387 ), "default" in ctor || console.error(
388 "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))",
389 ctor
390 ), ctor.default;
391 throw payload._result;
392 }
393 function resolveDispatcher() {
394 var dispatcher = ReactSharedInternals.H;
395 null === dispatcher && console.error(
396 "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
397 );
398 return dispatcher;
399 }
400 function noop() {
401 }
402 function enqueueTask(task) {
403 if (null === enqueueTaskImpl)
404 try {
405 var requireString = ("require" + Math.random()).slice(0, 7);
406 enqueueTaskImpl = (module && module[requireString]).call(
407 module,
408 "timers"
409 ).setImmediate;
410 } catch (_err) {
411 enqueueTaskImpl = function(callback) {
412 false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
413 "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
414 ));
415 var channel = new MessageChannel();
416 channel.port1.onmessage = callback;
417 channel.port2.postMessage(void 0);
418 };
419 }
420 return enqueueTaskImpl(task);
421 }
422 function aggregateErrors(errors) {
423 return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
424 }
425 function popActScope(prevActQueue, prevActScopeDepth) {
426 prevActScopeDepth !== actScopeDepth - 1 && console.error(
427 "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
428 );
429 actScopeDepth = prevActScopeDepth;
430 }
431 function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
432 var queue = ReactSharedInternals.actQueue;
433 if (null !== queue)
434 if (0 !== queue.length)
435 try {
436 flushActQueue(queue);
437 enqueueTask(function() {
438 return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
439 });
440 return;
441 } catch (error) {
442 ReactSharedInternals.thrownErrors.push(error);
443 }
444 else ReactSharedInternals.actQueue = null;
445 0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
446 }
447 function flushActQueue(queue) {
448 if (!isFlushing) {
449 isFlushing = true;
450 var i = 0;
451 try {
452 for (; i < queue.length; i++) {
453 var callback = queue[i];
454 do {
455 ReactSharedInternals.didUsePromise = false;
456 var continuation = callback(false);
457 if (null !== continuation) {
458 if (ReactSharedInternals.didUsePromise) {
459 queue[i] = callback;
460 queue.splice(0, i);
461 return;
462 }
463 callback = continuation;
464 } else break;
465 } while (1);
466 }
467 queue.length = 0;
468 } catch (error) {
469 queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
470 } finally {
471 isFlushing = false;
472 }
473 }
474 }
475 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
476 var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
477 Symbol.for("react.provider");
478 var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
479 isMounted: function() {
480 return false;
481 },
482 enqueueForceUpdate: function(publicInstance) {
483 warnNoop(publicInstance, "forceUpdate");
484 },
485 enqueueReplaceState: function(publicInstance) {
486 warnNoop(publicInstance, "replaceState");
487 },
488 enqueueSetState: function(publicInstance) {
489 warnNoop(publicInstance, "setState");
490 }
491 }, assign = Object.assign, emptyObject = {};
492 Object.freeze(emptyObject);
493 Component.prototype.isReactComponent = {};
494 Component.prototype.setState = function(partialState, callback) {
495 if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
496 throw Error(
497 "takes an object of state variables to update or a function which returns an object of state variables."
498 );
499 this.updater.enqueueSetState(this, partialState, callback, "setState");
500 };
501 Component.prototype.forceUpdate = function(callback) {
502 this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
503 };
504 var deprecatedAPIs = {
505 isMounted: [
506 "isMounted",
507 "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
508 ],
509 replaceState: [
510 "replaceState",
511 "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
512 ]
513 }, fnName;
514 for (fnName in deprecatedAPIs)
515 deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
516 ComponentDummy.prototype = Component.prototype;
517 deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
518 deprecatedAPIs.constructor = PureComponent;
519 assign(deprecatedAPIs, Component.prototype);
520 deprecatedAPIs.isPureReactComponent = true;
521 var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
522 H: null,
523 A: null,
524 T: null,
525 S: null,
526 V: null,
527 actQueue: null,
528 isBatchingLegacy: false,
529 didScheduleLegacyUpdate: false,
530 didUsePromise: false,
531 thrownErrors: [],
532 getCurrentStack: null,
533 recentlyCreatedOwnerStacks: 0
534 }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
535 return null;
536 };
537 deprecatedAPIs = {
538 react_stack_bottom_frame: function(callStackForError) {
539 return callStackForError();
540 }
541 };
542 var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
543 var didWarnAboutElementRef = {};
544 var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
545 deprecatedAPIs,
546 UnknownOwner
547 )();
548 var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
549 var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
550 if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
551 var event = new window.ErrorEvent("error", {
552 bubbles: true,
553 cancelable: true,
554 message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
555 error
556 });
557 if (!window.dispatchEvent(event)) return;
558 } else if ("object" === typeof process && "function" === typeof process.emit) {
559 process.emit("uncaughtException", error);
560 return;
561 }
562 console.error(error);
563 }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
564 queueMicrotask(function() {
565 return queueMicrotask(callback);
566 });
567 } : enqueueTask;
568 deprecatedAPIs = Object.freeze({
569 __proto__: null,
570 c: function(size) {
571 return resolveDispatcher().useMemoCache(size);
572 }
573 });
574 exports.Children = {
575 map: mapChildren,
576 forEach: function(children, forEachFunc, forEachContext) {
577 mapChildren(
578 children,
579 function() {
580 forEachFunc.apply(this, arguments);
581 },
582 forEachContext
583 );
584 },
585 count: function(children) {
586 var n = 0;
587 mapChildren(children, function() {
588 n++;
589 });
590 return n;
591 },
592 toArray: function(children) {
593 return mapChildren(children, function(child) {
594 return child;
595 }) || [];
596 },
597 only: function(children) {
598 if (!isValidElement(children))
599 throw Error(
600 "React.Children.only expected to receive a single React element child."
601 );
602 return children;
603 }
604 };
605 exports.Component = Component;
606 exports.Fragment = REACT_FRAGMENT_TYPE;
607 exports.Profiler = REACT_PROFILER_TYPE;
608 exports.PureComponent = PureComponent;
609 exports.StrictMode = REACT_STRICT_MODE_TYPE;
610 exports.Suspense = REACT_SUSPENSE_TYPE;
611 exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
612 exports.__COMPILER_RUNTIME = deprecatedAPIs;
613 exports.act = function(callback) {
614 var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
615 actScopeDepth++;
616 var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
617 try {
618 var result = callback();
619 } catch (error) {
620 ReactSharedInternals.thrownErrors.push(error);
621 }
622 if (0 < ReactSharedInternals.thrownErrors.length)
623 throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
624 if (null !== result && "object" === typeof result && "function" === typeof result.then) {
625 var thenable = result;
626 queueSeveralMicrotasks(function() {
627 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
628 "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
629 ));
630 });
631 return {
632 then: function(resolve, reject) {
633 didAwaitActCall = true;
634 thenable.then(
635 function(returnValue) {
636 popActScope(prevActQueue, prevActScopeDepth);
637 if (0 === prevActScopeDepth) {
638 try {
639 flushActQueue(queue), enqueueTask(function() {
640 return recursivelyFlushAsyncActWork(
641 returnValue,
642 resolve,
643 reject
644 );
645 });
646 } catch (error$0) {
647 ReactSharedInternals.thrownErrors.push(error$0);
648 }
649 if (0 < ReactSharedInternals.thrownErrors.length) {
650 var _thrownError = aggregateErrors(
651 ReactSharedInternals.thrownErrors
652 );
653 ReactSharedInternals.thrownErrors.length = 0;
654 reject(_thrownError);
655 }
656 } else resolve(returnValue);
657 },
658 function(error) {
659 popActScope(prevActQueue, prevActScopeDepth);
660 0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(
661 ReactSharedInternals.thrownErrors
662 ), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
663 }
664 );
665 }
666 };
667 }
668 var returnValue$jscomp$0 = result;
669 popActScope(prevActQueue, prevActScopeDepth);
670 0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
671 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
672 "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
673 ));
674 }), ReactSharedInternals.actQueue = null);
675 if (0 < ReactSharedInternals.thrownErrors.length)
676 throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
677 return {
678 then: function(resolve, reject) {
679 didAwaitActCall = true;
680 0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
681 return recursivelyFlushAsyncActWork(
682 returnValue$jscomp$0,
683 resolve,
684 reject
685 );
686 })) : resolve(returnValue$jscomp$0);
687 }
688 };
689 };
690 exports.cache = function(fn) {
691 return function() {
692 return fn.apply(null, arguments);
693 };
694 };
695 exports.captureOwnerStack = function() {
696 var getCurrentStack = ReactSharedInternals.getCurrentStack;
697 return null === getCurrentStack ? null : getCurrentStack();
698 };
699 exports.cloneElement = function(element, config, children) {
700 if (null === element || void 0 === element)
701 throw Error(
702 "The argument must be a React element, but you passed " + element + "."
703 );
704 var props = assign({}, element.props), key = element.key, owner = element._owner;
705 if (null != config) {
706 var JSCompiler_inline_result;
707 a: {
708 if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
709 config,
710 "ref"
711 ).get) && JSCompiler_inline_result.isReactWarning) {
712 JSCompiler_inline_result = false;
713 break a;
714 }
715 JSCompiler_inline_result = void 0 !== config.ref;
716 }
717 JSCompiler_inline_result && (owner = getOwner());
718 hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
719 for (propName in config)
720 !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
721 }
722 var propName = arguments.length - 2;
723 if (1 === propName) props.children = children;
724 else if (1 < propName) {
725 JSCompiler_inline_result = Array(propName);
726 for (var i = 0; i < propName; i++)
727 JSCompiler_inline_result[i] = arguments[i + 2];
728 props.children = JSCompiler_inline_result;
729 }
730 props = ReactElement(
731 element.type,
732 key,
733 void 0,
734 void 0,
735 owner,
736 props,
737 element._debugStack,
738 element._debugTask
739 );
740 for (key = 2; key < arguments.length; key++)
741 owner = arguments[key], isValidElement(owner) && owner._store && (owner._store.validated = 1);
742 return props;
743 };
744 exports.createContext = function(defaultValue) {
745 defaultValue = {
746 $$typeof: REACT_CONTEXT_TYPE,
747 _currentValue: defaultValue,
748 _currentValue2: defaultValue,
749 _threadCount: 0,
750 Provider: null,
751 Consumer: null
752 };
753 defaultValue.Provider = defaultValue;
754 defaultValue.Consumer = {
755 $$typeof: REACT_CONSUMER_TYPE,
756 _context: defaultValue
757 };
758 defaultValue._currentRenderer = null;
759 defaultValue._currentRenderer2 = null;
760 return defaultValue;
761 };
762 exports.createElement = function(type, config, children) {
763 for (var i = 2; i < arguments.length; i++) {
764 var node = arguments[i];
765 isValidElement(node) && node._store && (node._store.validated = 1);
766 }
767 i = {};
768 node = null;
769 if (null != config)
770 for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn(
771 "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
772 )), hasValidKey(config) && (checkKeyStringCoercion(config.key), node = "" + config.key), config)
773 hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
774 var childrenLength = arguments.length - 2;
775 if (1 === childrenLength) i.children = children;
776 else if (1 < childrenLength) {
777 for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++)
778 childArray[_i] = arguments[_i + 2];
779 Object.freeze && Object.freeze(childArray);
780 i.children = childArray;
781 }
782 if (type && type.defaultProps)
783 for (propName in childrenLength = type.defaultProps, childrenLength)
784 void 0 === i[propName] && (i[propName] = childrenLength[propName]);
785 node && defineKeyPropWarningGetter(
786 i,
787 "function" === typeof type ? type.displayName || type.name || "Unknown" : type
788 );
789 var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
790 return ReactElement(
791 type,
792 node,
793 void 0,
794 void 0,
795 getOwner(),
796 i,
797 propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
798 propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
799 );
800 };
801 exports.createRef = function() {
802 var refObject = { current: null };
803 Object.seal(refObject);
804 return refObject;
805 };
806 exports.forwardRef = function(render) {
807 null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
808 "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
809 ) : "function" !== typeof render ? console.error(
810 "forwardRef requires a render function but was given %s.",
811 null === render ? "null" : typeof render
812 ) : 0 !== render.length && 2 !== render.length && console.error(
813 "forwardRef render functions accept exactly two parameters: props and ref. %s",
814 1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
815 );
816 null != render && null != render.defaultProps && console.error(
817 "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
818 );
819 var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
820 Object.defineProperty(elementType, "displayName", {
821 enumerable: false,
822 configurable: true,
823 get: function() {
824 return ownName;
825 },
826 set: function(name) {
827 ownName = name;
828 render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
829 }
830 });
831 return elementType;
832 };
833 exports.isValidElement = isValidElement;
834 exports.lazy = function(ctor) {
835 return {
836 $$typeof: REACT_LAZY_TYPE,
837 _payload: { _status: -1, _result: ctor },
838 _init: lazyInitializer
839 };
840 };
841 exports.memo = function(type, compare) {
842 null == type && console.error(
843 "memo: The first argument must be a component. Instead received: %s",
844 null === type ? "null" : typeof type
845 );
846 compare = {
847 $$typeof: REACT_MEMO_TYPE,
848 type,
849 compare: void 0 === compare ? null : compare
850 };
851 var ownName;
852 Object.defineProperty(compare, "displayName", {
853 enumerable: false,
854 configurable: true,
855 get: function() {
856 return ownName;
857 },
858 set: function(name) {
859 ownName = name;
860 type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
861 }
862 });
863 return compare;
864 };
865 exports.startTransition = function(scope) {
866 var prevTransition = ReactSharedInternals.T, currentTransition = {};
867 ReactSharedInternals.T = currentTransition;
868 currentTransition._updatedFibers = /* @__PURE__ */ new Set();
869 try {
870 var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
871 null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
872 "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
873 } catch (error) {
874 reportGlobalError(error);
875 } finally {
876 null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn(
877 "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
878 )), ReactSharedInternals.T = prevTransition;
879 }
880 };
881 exports.unstable_useCacheRefresh = function() {
882 return resolveDispatcher().useCacheRefresh();
883 };
884 exports.use = function(usable) {
885 return resolveDispatcher().use(usable);
886 };
887 exports.useActionState = function(action, initialState, permalink) {
888 return resolveDispatcher().useActionState(
889 action,
890 initialState,
891 permalink
892 );
893 };
894 exports.useCallback = function(callback, deps) {
895 return resolveDispatcher().useCallback(callback, deps);
896 };
897 exports.useContext = function(Context) {
898 var dispatcher = resolveDispatcher();
899 Context.$$typeof === REACT_CONSUMER_TYPE && console.error(
900 "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
901 );
902 return dispatcher.useContext(Context);
903 };
904 exports.useDebugValue = function(value, formatterFn) {
905 return resolveDispatcher().useDebugValue(value, formatterFn);
906 };
907 exports.useDeferredValue = function(value, initialValue) {
908 return resolveDispatcher().useDeferredValue(value, initialValue);
909 };
910 exports.useEffect = function(create, createDeps, update) {
911 null == create && console.warn(
912 "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
913 );
914 var dispatcher = resolveDispatcher();
915 if ("function" === typeof update)
916 throw Error(
917 "useEffect CRUD overload is not enabled in this build of React."
918 );
919 return dispatcher.useEffect(create, createDeps);
920 };
921 exports.useId = function() {
922 return resolveDispatcher().useId();
923 };
924 exports.useImperativeHandle = function(ref, create, deps) {
925 return resolveDispatcher().useImperativeHandle(ref, create, deps);
926 };
927 exports.useInsertionEffect = function(create, deps) {
928 null == create && console.warn(
929 "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
930 );
931 return resolveDispatcher().useInsertionEffect(create, deps);
932 };
933 exports.useLayoutEffect = function(create, deps) {
934 null == create && console.warn(
935 "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
936 );
937 return resolveDispatcher().useLayoutEffect(create, deps);
938 };
939 exports.useMemo = function(create, deps) {
940 return resolveDispatcher().useMemo(create, deps);
941 };
942 exports.useOptimistic = function(passthrough, reducer) {
943 return resolveDispatcher().useOptimistic(passthrough, reducer);
944 };
945 exports.useReducer = function(reducer, initialArg, init) {
946 return resolveDispatcher().useReducer(reducer, initialArg, init);
947 };
948 exports.useRef = function(initialValue) {
949 return resolveDispatcher().useRef(initialValue);
950 };
951 exports.useState = function(initialState) {
952 return resolveDispatcher().useState(initialState);
953 };
954 exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
955 return resolveDispatcher().useSyncExternalStore(
956 subscribe,
957 getSnapshot,
958 getServerSnapshot
959 );
960 };
961 exports.useTransition = function() {
962 return resolveDispatcher().useTransition();
963 };
964 exports.version = "19.1.1";
965 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
966 })();
967 }
968 });
969
970 // node_modules/react/index.js
971 var require_react = __commonJS({
972 "node_modules/react/index.js"(exports, module) {
973 "use strict";
974 if (false) {
975 module.exports = null;
976 } else {
977 module.exports = require_react_development();
978 }
979 }
980 });
981
982 // node_modules/react/cjs/react-jsx-runtime.development.js
983 var require_react_jsx_runtime_development = __commonJS({
984 "node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
985 "use strict";
986 (function() {
987 function getComponentNameFromType(type) {
988 if (null == type) return null;
989 if ("function" === typeof type)
990 return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
991 if ("string" === typeof type) return type;
992 switch (type) {
993 case REACT_FRAGMENT_TYPE:
994 return "Fragment";
995 case REACT_PROFILER_TYPE:
996 return "Profiler";
997 case REACT_STRICT_MODE_TYPE:
998 return "StrictMode";
999 case REACT_SUSPENSE_TYPE:
1000 return "Suspense";
1001 case REACT_SUSPENSE_LIST_TYPE:
1002 return "SuspenseList";
1003 case REACT_ACTIVITY_TYPE:
1004 return "Activity";
1005 }
1006 if ("object" === typeof type)
1007 switch ("number" === typeof type.tag && console.error(
1008 "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
1009 ), type.$$typeof) {
1010 case REACT_PORTAL_TYPE:
1011 return "Portal";
1012 case REACT_CONTEXT_TYPE:
1013 return (type.displayName || "Context") + ".Provider";
1014 case REACT_CONSUMER_TYPE:
1015 return (type._context.displayName || "Context") + ".Consumer";
1016 case REACT_FORWARD_REF_TYPE:
1017 var innerType = type.render;
1018 type = type.displayName;
1019 type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
1020 return type;
1021 case REACT_MEMO_TYPE:
1022 return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
1023 case REACT_LAZY_TYPE:
1024 innerType = type._payload;
1025 type = type._init;
1026 try {
1027 return getComponentNameFromType(type(innerType));
1028 } catch (x) {
1029 }
1030 }
1031 return null;
1032 }
1033 function testStringCoercion(value) {
1034 return "" + value;
1035 }
1036 function checkKeyStringCoercion(value) {
1037 try {
1038 testStringCoercion(value);
1039 var JSCompiler_inline_result = false;
1040 } catch (e) {
1041 JSCompiler_inline_result = true;
1042 }
1043 if (JSCompiler_inline_result) {
1044 JSCompiler_inline_result = console;
1045 var JSCompiler_temp_const = JSCompiler_inline_result.error;
1046 var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
1047 JSCompiler_temp_const.call(
1048 JSCompiler_inline_result,
1049 "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
1050 JSCompiler_inline_result$jscomp$0
1051 );
1052 return testStringCoercion(value);
1053 }
1054 }
1055 function getTaskName(type) {
1056 if (type === REACT_FRAGMENT_TYPE) return "<>";
1057 if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
1058 return "<...>";
1059 try {
1060 var name = getComponentNameFromType(type);
1061 return name ? "<" + name + ">" : "<...>";
1062 } catch (x) {
1063 return "<...>";
1064 }
1065 }
1066 function getOwner() {
1067 var dispatcher = ReactSharedInternals.A;
1068 return null === dispatcher ? null : dispatcher.getOwner();
1069 }
1070 function UnknownOwner() {
1071 return Error("react-stack-top-frame");
1072 }
1073 function hasValidKey(config) {
1074 if (hasOwnProperty.call(config, "key")) {
1075 var getter = Object.getOwnPropertyDescriptor(config, "key").get;
1076 if (getter && getter.isReactWarning) return false;
1077 }
1078 return void 0 !== config.key;
1079 }
1080 function defineKeyPropWarningGetter(props, displayName) {
1081 function warnAboutAccessingKey() {
1082 specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
1083 "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
1084 displayName
1085 ));
1086 }
1087 warnAboutAccessingKey.isReactWarning = true;
1088 Object.defineProperty(props, "key", {
1089 get: warnAboutAccessingKey,
1090 configurable: true
1091 });
1092 }
1093 function elementRefGetterWithDeprecationWarning() {
1094 var componentName = getComponentNameFromType(this.type);
1095 didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
1096 "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
1097 ));
1098 componentName = this.props.ref;
1099 return void 0 !== componentName ? componentName : null;
1100 }
1101 function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
1102 self = props.ref;
1103 type = {
1104 $$typeof: REACT_ELEMENT_TYPE,
1105 type,
1106 key,
1107 props,
1108 _owner: owner
1109 };
1110 null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
1111 enumerable: false,
1112 get: elementRefGetterWithDeprecationWarning
1113 }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
1114 type._store = {};
1115 Object.defineProperty(type._store, "validated", {
1116 configurable: false,
1117 enumerable: false,
1118 writable: true,
1119 value: 0
1120 });
1121 Object.defineProperty(type, "_debugInfo", {
1122 configurable: false,
1123 enumerable: false,
1124 writable: true,
1125 value: null
1126 });
1127 Object.defineProperty(type, "_debugStack", {
1128 configurable: false,
1129 enumerable: false,
1130 writable: true,
1131 value: debugStack
1132 });
1133 Object.defineProperty(type, "_debugTask", {
1134 configurable: false,
1135 enumerable: false,
1136 writable: true,
1137 value: debugTask
1138 });
1139 Object.freeze && (Object.freeze(type.props), Object.freeze(type));
1140 return type;
1141 }
1142 function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self, debugStack, debugTask) {
1143 var children = config.children;
1144 if (void 0 !== children)
1145 if (isStaticChildren)
1146 if (isArrayImpl(children)) {
1147 for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
1148 validateChildKeys(children[isStaticChildren]);
1149 Object.freeze && Object.freeze(children);
1150 } else
1151 console.error(
1152 "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
1153 );
1154 else validateChildKeys(children);
1155 if (hasOwnProperty.call(config, "key")) {
1156 children = getComponentNameFromType(type);
1157 var keys = Object.keys(config).filter(function(k) {
1158 return "key" !== k;
1159 });
1160 isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
1161 didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
1162 '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} />',
1163 isStaticChildren,
1164 children,
1165 keys,
1166 children
1167 ), didWarnAboutKeySpread[children + isStaticChildren] = true);
1168 }
1169 children = null;
1170 void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
1171 hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
1172 if ("key" in config) {
1173 maybeKey = {};
1174 for (var propName in config)
1175 "key" !== propName && (maybeKey[propName] = config[propName]);
1176 } else maybeKey = config;
1177 children && defineKeyPropWarningGetter(
1178 maybeKey,
1179 "function" === typeof type ? type.displayName || type.name || "Unknown" : type
1180 );
1181 return ReactElement(
1182 type,
1183 children,
1184 self,
1185 source,
1186 getOwner(),
1187 maybeKey,
1188 debugStack,
1189 debugTask
1190 );
1191 }
1192 function validateChildKeys(node) {
1193 "object" === typeof node && null !== node && node.$$typeof === REACT_ELEMENT_TYPE && node._store && (node._store.validated = 1);
1194 }
1195 var React = require_react(), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
1196 Symbol.for("react.provider");
1197 var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
1198 return null;
1199 };
1200 React = {
1201 react_stack_bottom_frame: function(callStackForError) {
1202 return callStackForError();
1203 }
1204 };
1205 var specialPropKeyWarningShown;
1206 var didWarnAboutElementRef = {};
1207 var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
1208 React,
1209 UnknownOwner
1210 )();
1211 var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
1212 var didWarnAboutKeySpread = {};
1213 exports.Fragment = REACT_FRAGMENT_TYPE;
1214 exports.jsx = function(type, config, maybeKey, source, self) {
1215 var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
1216 return jsxDEVImpl(
1217 type,
1218 config,
1219 maybeKey,
1220 false,
1221 source,
1222 self,
1223 trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
1224 trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
1225 );
1226 };
1227 exports.jsxs = function(type, config, maybeKey, source, self) {
1228 var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
1229 return jsxDEVImpl(
1230 type,
1231 config,
1232 maybeKey,
1233 true,
1234 source,
1235 self,
1236 trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
1237 trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
1238 );
1239 };
1240 })();
1241 }
1242 });
1243
1244 // node_modules/react/jsx-runtime.js
1245 var require_jsx_runtime = __commonJS({
1246 "node_modules/react/jsx-runtime.js"(exports, module) {
1247 "use strict";
1248 if (false) {
1249 module.exports = null;
1250 } else {
1251 module.exports = require_react_jsx_runtime_development();
1252 }
1253 }
1254 });
1255
1256 export {
1257 __commonJS,
1258 __toESM,
1259 require_react,
1260 require_jsx_runtime
1261 };
1262 /*! Bundled license information:
1263
1264 react/cjs/react.development.js:
1265 (**
1266 * @license React
1267 * react.development.js
1268 *
1269 * Copyright (c) Meta Platforms, Inc. and affiliates.
1270 *
1271 * This source code is licensed under the MIT license found in the
1272 * LICENSE file in the root directory of this source tree.
1273 *)
1274
1275 react/cjs/react-jsx-runtime.development.js:
1276 (**
1277 * @license React
1278 * react-jsx-runtime.development.js
1279 *
1280 * Copyright (c) Meta Platforms, Inc. and affiliates.
1281 *
1282 * This source code is licensed under the MIT license found in the
1283 * LICENSE file in the root directory of this source tree.
1284 *)
1285 */
1286 //# sourceMappingURL=chunk-AX5M7HF6.js.map