Gutenberg / 24.1.0

Gutenberg v24.1.0

gutenberg / build / scripts / vendors / react-19-orig.js

react-19-orig.js in Gutenberg 24.1.0, at build/scripts/vendors/react-19-orig.js

1,111 lines 51.5 KB

Raw Download Zip

1	var React = (() => {
2	var __defProp = Object.defineProperty;
3	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4	var __getOwnPropNames = Object.getOwnPropertyNames;
5	var __hasOwnProp = Object.prototype.hasOwnProperty;
6	var __esm = (fn, res) => function __init() {
7	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
8	};
9	var __commonJS = (cb, mod) => function __require() {
10	return mod \|\| (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
11	};
12	var __export = (target, all) => {
13	for (var name in all)
14	__defProp(target, name, { get: all[name], enumerable: true });
15	};
16	var __copyProps = (to, from, except, desc) => {
17	if (from && typeof from === "object" \|\| typeof from === "function") {
18	for (let key of __getOwnPropNames(from))
19	if (!__hasOwnProp.call(to, key) && key !== except)
20	__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
21	}
22	return to;
23	};
24	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
25
26	// ../react-19/warn-compat.js
27	var warn_compat_exports = {};
28	__export(warn_compat_exports, {
29	warnCompat: () => warnCompat
30	});
31	function warnCompat(key, message) {
32	if (warned.has(key)) {
33	return;
34	}
35	warned.add(key);
36	if (typeof console !== "undefined" && console.warn) {
37	console.warn(`${PREFIX} ${message}`);
38	}
39	}
40	var PREFIX, warned;
41	var init_warn_compat = __esm({
42	"../react-19/warn-compat.js"() {
43	PREFIX = "[wordpress-react-19]";
44	warned = /* @__PURE__ */ new Set();
45	}
46	});
47
48	// ../react-19/node_modules/react/cjs/react.development.js
49	var require_react_development = __commonJS({
50	"../react-19/node_modules/react/cjs/react.development.js"(exports, module) {
51	"use strict";
52	(function() {
53	function defineDeprecationWarning(methodName, info) {
54	Object.defineProperty(Component.prototype, methodName, {
55	get: function() {
56	console.warn(
57	"%s(...) is deprecated in plain JavaScript React classes. %s",
58	info[0],
59	info[1]
60	);
61	}
62	});
63	}
64	function getIteratorFn(maybeIterable) {
65	if (null === maybeIterable \|\| "object" !== typeof maybeIterable)
66	return null;
67	maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] \|\| maybeIterable["@@iterator"];
68	return "function" === typeof maybeIterable ? maybeIterable : null;
69	}
70	function warnNoop(publicInstance, callerName) {
71	publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName \|\| publicInstance.name) \|\| "ReactClass";
72	var warningKey = publicInstance + "." + callerName;
73	didWarnStateUpdateForUnmountedComponent[warningKey] \|\| (console.error(
74	"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.",
75	callerName,
76	publicInstance
77	), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
78	}
79	function Component(props, context, updater) {
80	this.props = props;
81	this.context = context;
82	this.refs = emptyObject;
83	this.updater = updater \|\| ReactNoopUpdateQueue;
84	}
85	function ComponentDummy() {
86	}
87	function PureComponent(props, context, updater) {
88	this.props = props;
89	this.context = context;
90	this.refs = emptyObject;
91	this.updater = updater \|\| ReactNoopUpdateQueue;
92	}
93	function noop() {
94	}
95	function testStringCoercion(value) {
96	return "" + value;
97	}
98	function checkKeyStringCoercion(value) {
99	try {
100	testStringCoercion(value);
101	var JSCompiler_inline_result = false;
102	} catch (e) {
103	JSCompiler_inline_result = true;
104	}
105	if (JSCompiler_inline_result) {
106	JSCompiler_inline_result = console;
107	var JSCompiler_temp_const = JSCompiler_inline_result.error;
108	var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] \|\| value.constructor.name \|\| "Object";
109	JSCompiler_temp_const.call(
110	JSCompiler_inline_result,
111	"The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
112	JSCompiler_inline_result$jscomp$0
113	);
114	return testStringCoercion(value);
115	}
116	}
117	function getComponentNameFromType(type) {
118	if (null == type) return null;
119	if ("function" === typeof type)
120	return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName \|\| type.name \|\| null;
121	if ("string" === typeof type) return type;
122	switch (type) {
123	case REACT_FRAGMENT_TYPE:
124	return "Fragment";
125	case REACT_PROFILER_TYPE:
126	return "Profiler";
127	case REACT_STRICT_MODE_TYPE:
128	return "StrictMode";
129	case REACT_SUSPENSE_TYPE:
130	return "Suspense";
131	case REACT_SUSPENSE_LIST_TYPE:
132	return "SuspenseList";
133	case REACT_ACTIVITY_TYPE:
134	return "Activity";
135	case REACT_VIEW_TRANSITION_TYPE:
136	return "ViewTransition";
137	}
138	if ("object" === typeof type)
139	switch ("number" === typeof type.tag && console.error(
140	"Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
141	), type.$$typeof) {
142	case REACT_PORTAL_TYPE:
143	return "Portal";
144	case REACT_CONTEXT_TYPE:
145	return type.displayName \|\| "Context";
146	case REACT_CONSUMER_TYPE:
147	return (type._context.displayName \|\| "Context") + ".Consumer";
148	case REACT_FORWARD_REF_TYPE:
149	var innerType = type.render;
150	type = type.displayName;
151	type \|\| (type = innerType.displayName \|\| innerType.name \|\| "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
152	return type;
153	case REACT_MEMO_TYPE:
154	return innerType = type.displayName \|\| null, null !== innerType ? innerType : getComponentNameFromType(type.type) \|\| "Memo";
155	case REACT_LAZY_TYPE:
156	innerType = type._payload;
157	type = type._init;
158	try {
159	return getComponentNameFromType(type(innerType));
160	} catch (x) {
161	}
162	}
163	return null;
164	}
165	function getTaskName(type) {
166	if (type === REACT_FRAGMENT_TYPE) return "<>";
167	if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
168	return "<...>";
169	try {
170	var name = getComponentNameFromType(type);
171	return name ? "<" + name + ">" : "<...>";
172	} catch (x) {
173	return "<...>";
174	}
175	}
176	function getOwner() {
177	var dispatcher = ReactSharedInternals.A;
178	return null === dispatcher ? null : dispatcher.getOwner();
179	}
180	function UnknownOwner() {
181	return Error("react-stack-top-frame");
182	}
183	function hasValidKey(config) {
184	if (hasOwnProperty.call(config, "key")) {
185	var getter = Object.getOwnPropertyDescriptor(config, "key").get;
186	if (getter && getter.isReactWarning) return false;
187	}
188	return void 0 !== config.key;
189	}
190	function defineKeyPropWarningGetter(props, displayName) {
191	function warnAboutAccessingKey() {
192	specialPropKeyWarningShown \|\| (specialPropKeyWarningShown = true, console.error(
193	"%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)",
194	displayName
195	));
196	}
197	warnAboutAccessingKey.isReactWarning = true;
198	Object.defineProperty(props, "key", {
199	get: warnAboutAccessingKey,
200	configurable: true
201	});
202	}
203	function elementRefGetterWithDeprecationWarning() {
204	var componentName = getComponentNameFromType(this.type);
205	didWarnAboutElementRef[componentName] \|\| (didWarnAboutElementRef[componentName] = true, console.error(
206	"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."
207	));
208	componentName = this.props.ref;
209	return void 0 !== componentName ? componentName : null;
210	}
211	function ReactElement(type, key, props, owner, debugStack, debugTask) {
212	var refProp = props.ref;
213	type = {
214	$$typeof: REACT_ELEMENT_TYPE,
215	type,
216	key,
217	props,
218	_owner: owner
219	};
220	null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
221	enumerable: false,
222	get: elementRefGetterWithDeprecationWarning
223	}) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
224	type._store = {};
225	Object.defineProperty(type._store, "validated", {
226	configurable: false,
227	enumerable: false,
228	writable: true,
229	value: 0
230	});
231	Object.defineProperty(type, "_debugInfo", {
232	configurable: false,
233	enumerable: false,
234	writable: true,
235	value: null
236	});
237	Object.defineProperty(type, "_debugStack", {
238	configurable: false,
239	enumerable: false,
240	writable: true,
241	value: debugStack
242	});
243	Object.defineProperty(type, "_debugTask", {
244	configurable: false,
245	enumerable: false,
246	writable: true,
247	value: debugTask
248	});
249	Object.freeze && (Object.freeze(type.props), Object.freeze(type));
250	return type;
251	}
252	function cloneAndReplaceKey(oldElement, newKey) {
253	newKey = ReactElement(
254	oldElement.type,
255	newKey,
256	oldElement.props,
257	oldElement._owner,
258	oldElement._debugStack,
259	oldElement._debugTask
260	);
261	oldElement._store && (newKey._store.validated = oldElement._store.validated);
262	return newKey;
263	}
264	function validateChildKeys(node) {
265	isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
266	}
267	function isValidElement(object) {
268	return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
269	}
270	function escape(key) {
271	var escaperLookup = { "=": "=0", ":": "=2" };
272	return "$" + key.replace(/[=:]/g, function(match) {
273	return escaperLookup[match];
274	});
275	}
276	function getElementKey(element, index) {
277	return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
278	}
279	function resolveThenable(thenable) {
280	switch (thenable.status) {
281	case "fulfilled":
282	return thenable.value;
283	case "rejected":
284	throw thenable.reason;
285	default:
286	switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
287	function(fulfilledValue) {
288	"pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
289	},
290	function(error) {
291	"pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
292	}
293	)), thenable.status) {
294	case "fulfilled":
295	return thenable.value;
296	case "rejected":
297	throw thenable.reason;
298	}
299	}
300	throw thenable;
301	}
302	function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
303	var type = typeof children;
304	if ("undefined" === type \|\| "boolean" === type) children = null;
305	var invokeCallback = false;
306	if (null === children) invokeCallback = true;
307	else
308	switch (type) {
309	case "bigint":
310	case "string":
311	case "number":
312	invokeCallback = true;
313	break;
314	case "object":
315	switch (children.$$typeof) {
316	case REACT_ELEMENT_TYPE:
317	case REACT_PORTAL_TYPE:
318	invokeCallback = true;
319	break;
320	case REACT_LAZY_TYPE:
321	return invokeCallback = children._init, mapIntoArray(
322	invokeCallback(children._payload),
323	array,
324	escapedPrefix,
325	nameSoFar,
326	callback
327	);
328	}
329	}
330	if (invokeCallback) {
331	invokeCallback = children;
332	callback = callback(invokeCallback);
333	var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
334	isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
335	return c;
336	})) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key \|\| checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(
337	callback,
338	escapedPrefix + (null == callback.key \|\| invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(
339	userProvidedKeyEscapeRegex,
340	"$&/"
341	) + "/") + childKey
342	), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
343	return 1;
344	}
345	invokeCallback = 0;
346	childKey = "" === nameSoFar ? "." : nameSoFar + ":";
347	if (isArrayImpl(children))
348	for (var i = 0; i < children.length; i++)
349	nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
350	nameSoFar,
351	array,
352	escapedPrefix,
353	type,
354	callback
355	);
356	else if (i = getIteratorFn(children), "function" === typeof i)
357	for (i === children.entries && (didWarnAboutMaps \|\| console.warn(
358	"Using Maps as children is not supported. Use an array of keyed ReactElements instead."
359	), didWarnAboutMaps = true), children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
360	nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
361	nameSoFar,
362	array,
363	escapedPrefix,
364	type,
365	callback
366	);
367	else if ("object" === type) {
368	if ("function" === typeof children.then)
369	return mapIntoArray(
370	resolveThenable(children),
371	array,
372	escapedPrefix,
373	nameSoFar,
374	callback
375	);
376	array = String(children);
377	throw Error(
378	"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."
379	);
380	}
381	return invokeCallback;
382	}
383	function mapChildren(children, func, context) {
384	if (null == children) return children;
385	var result = [], count = 0;
386	mapIntoArray(children, result, "", "", function(child) {
387	return func.call(context, child, count++);
388	});
389	return result;
390	}
391	function lazyInitializer(payload) {
392	if (-1 === payload._status) {
393	var resolveDebugValue = null, rejectDebugValue = null, ioInfo = payload._ioInfo;
394	null != ioInfo && (ioInfo.start = ioInfo.end = performance.now(), ioInfo.value = new Promise(function(resolve, reject) {
395	resolveDebugValue = resolve;
396	rejectDebugValue = reject;
397	}));
398	ioInfo = payload._result;
399	var thenable = ioInfo();
400	thenable.then(
401	function(moduleObject) {
402	if (0 === payload._status \|\| -1 === payload._status) {
403	payload._status = 1;
404	payload._result = moduleObject;
405	var _ioInfo = payload._ioInfo;
406	if (null != _ioInfo) {
407	_ioInfo.end = performance.now();
408	var debugValue = null == moduleObject ? void 0 : moduleObject.default;
409	resolveDebugValue(debugValue);
410	_ioInfo.value.status = "fulfilled";
411	_ioInfo.value.value = debugValue;
412	}
413	void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
414	}
415	},
416	function(error) {
417	if (0 === payload._status \|\| -1 === payload._status) {
418	payload._status = 2;
419	payload._result = error;
420	var _ioInfo2 = payload._ioInfo;
421	null != _ioInfo2 && (_ioInfo2.end = performance.now(), _ioInfo2.value.then(noop, noop), rejectDebugValue(error), _ioInfo2.value.status = "rejected", _ioInfo2.value.reason = error);
422	void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error);
423	}
424	}
425	);
426	ioInfo = payload._ioInfo;
427	if (null != ioInfo) {
428	var displayName = thenable.displayName;
429	"string" === typeof displayName && (ioInfo.name = displayName);
430	}
431	-1 === payload._status && (payload._status = 0, payload._result = thenable);
432	}
433	if (1 === payload._status)
434	return ioInfo = payload._result, void 0 === ioInfo && console.error(
435	"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?",
436	ioInfo
437	), "default" in ioInfo \|\| console.error(
438	"lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))",
439	ioInfo
440	), ioInfo.default;
441	throw payload._result;
442	}
443	function resolveDispatcher() {
444	var dispatcher = ReactSharedInternals.H;
445	null === dispatcher && console.error(
446	"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."
447	);
448	return dispatcher;
449	}
450	function releaseAsyncTransition() {
451	ReactSharedInternals.asyncTransitions--;
452	}
453	function startTransition(scope) {
454	var prevTransition = ReactSharedInternals.T, currentTransition = {};
455	currentTransition.types = null !== prevTransition ? prevTransition.types : null;
456	currentTransition._updatedFibers = /* @__PURE__ */ new Set();
457	ReactSharedInternals.T = currentTransition;
458	try {
459	var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
460	null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
461	"object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
462	} catch (error) {
463	reportGlobalError(error);
464	} finally {
465	null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn(
466	"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."
467	)), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
468	"We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
469	), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
470	}
471	}
472	function addTransitionType(type) {
473	var transition = ReactSharedInternals.T;
474	if (null !== transition) {
475	var transitionTypes = transition.types;
476	null === transitionTypes ? transition.types = [type] : -1 === transitionTypes.indexOf(type) && transitionTypes.push(type);
477	} else
478	0 === ReactSharedInternals.asyncTransitions && console.error(
479	"addTransitionType can only be called inside a `startTransition()` callback. It must be associated with a specific Transition."
480	), startTransition(addTransitionType.bind(null, type));
481	}
482	function enqueueTask(task) {
483	if (null === enqueueTaskImpl)
484	try {
485	var requireString = ("require" + Math.random()).slice(0, 7);
486	enqueueTaskImpl = (module && module[requireString]).call(
487	module,
488	"timers"
489	).setImmediate;
490	} catch (_err) {
491	enqueueTaskImpl = function(callback) {
492	false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
493	"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."
494	));
495	var channel = new MessageChannel();
496	channel.port1.onmessage = callback;
497	channel.port2.postMessage(void 0);
498	};
499	}
500	return enqueueTaskImpl(task);
501	}
502	function aggregateErrors(errors) {
503	return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
504	}
505	function popActScope(prevActQueue, prevActScopeDepth) {
506	prevActScopeDepth !== actScopeDepth - 1 && console.error(
507	"You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
508	);
509	actScopeDepth = prevActScopeDepth;
510	}
511	function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
512	var queue = ReactSharedInternals.actQueue;
513	if (null !== queue)
514	if (0 !== queue.length)
515	try {
516	flushActQueue(queue);
517	enqueueTask(function() {
518	return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
519	});
520	return;
521	} catch (error) {
522	ReactSharedInternals.thrownErrors.push(error);
523	}
524	else ReactSharedInternals.actQueue = null;
525	0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
526	}
527	function flushActQueue(queue) {
528	if (!isFlushing) {
529	isFlushing = true;
530	var i = 0;
531	try {
532	for (; i < queue.length; i++) {
533	var callback = queue[i];
534	do {
535	ReactSharedInternals.didUsePromise = false;
536	var continuation = callback(false);
537	if (null !== continuation) {
538	if (ReactSharedInternals.didUsePromise) {
539	queue[i] = callback;
540	queue.splice(0, i);
541	return;
542	}
543	callback = continuation;
544	} else break;
545	} while (1);
546	}
547	queue.length = 0;
548	} catch (error) {
549	queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
550	} finally {
551	isFlushing = false;
552	}
553	}
554	}
555	"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
556	var REACT_ELEMENT_TYPE = /* @__PURE__ / Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = / @__PURE__ / Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = / @__PURE__ / Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = / @__PURE__ / Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = / @__PURE__ / Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = / @__PURE__ / Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = / @__PURE__ / Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = / @__PURE__ / Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = / @__PURE__ / Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = / @__PURE__ / Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = / @__PURE__ / Symbol.for("react.memo"), REACT_LAZY_TYPE = / @__PURE__ / Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = / @__PURE__ / Symbol.for("react.activity"), REACT_VIEW_TRANSITION_TYPE = / @__PURE__ */ Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
557	isMounted: function() {
558	return false;
559	},
560	enqueueForceUpdate: function(publicInstance) {
561	warnNoop(publicInstance, "forceUpdate");
562	},
563	enqueueReplaceState: function(publicInstance) {
564	warnNoop(publicInstance, "replaceState");
565	},
566	enqueueSetState: function(publicInstance) {
567	warnNoop(publicInstance, "setState");
568	}
569	}, assign = Object.assign, emptyObject = {};
570	Object.freeze(emptyObject);
571	Component.prototype.isReactComponent = {};
572	Component.prototype.setState = function(partialState, callback) {
573	if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
574	throw Error(
575	"takes an object of state variables to update or a function which returns an object of state variables."
576	);
577	this.updater.enqueueSetState(this, partialState, callback, "setState");
578	};
579	Component.prototype.forceUpdate = function(callback) {
580	this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
581	};
582	var deprecatedAPIs = {
583	isMounted: [
584	"isMounted",
585	"Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
586	],
587	replaceState: [
588	"replaceState",
589	"Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
590	]
591	};
592	for (fnName in deprecatedAPIs)
593	deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
594	ComponentDummy.prototype = Component.prototype;
595	deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
596	deprecatedAPIs.constructor = PureComponent;
597	assign(deprecatedAPIs, Component.prototype);
598	deprecatedAPIs.isPureReactComponent = true;
599	var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = {
600	H: null,
601	A: null,
602	T: null,
603	S: null,
604	actQueue: null,
605	asyncTransitions: 0,
606	isBatchingLegacy: false,
607	didScheduleLegacyUpdate: false,
608	didUsePromise: false,
609	thrownErrors: [],
610	getCurrentStack: null,
611	recentlyCreatedOwnerStacks: 0
612	}, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
613	return null;
614	};
615	deprecatedAPIs = {
616	react_stack_bottom_frame: function(callStackForError) {
617	return callStackForError();
618	}
619	};
620	var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
621	var didWarnAboutElementRef = {};
622	var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
623	deprecatedAPIs,
624	UnknownOwner
625	)();
626	var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
627	var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
628	if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
629	var event = new window.ErrorEvent("error", {
630	bubbles: true,
631	cancelable: true,
632	message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
633	error
634	});
635	if (!window.dispatchEvent(event)) return;
636	} else if ("object" === typeof process && "function" === typeof process.emit) {
637	process.emit("uncaughtException", error);
638	return;
639	}
640	console.error(error);
641	}, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
642	queueMicrotask(function() {
643	return queueMicrotask(callback);
644	});
645	} : enqueueTask;
646	deprecatedAPIs = Object.freeze({
647	__proto__: null,
648	c: function(size) {
649	return resolveDispatcher().useMemoCache(size);
650	}
651	});
652	var fnName = {
653	map: mapChildren,
654	forEach: function(children, forEachFunc, forEachContext) {
655	mapChildren(
656	children,
657	function() {
658	forEachFunc.apply(this, arguments);
659	},
660	forEachContext
661	);
662	},
663	count: function(children) {
664	var n = 0;
665	mapChildren(children, function() {
666	n++;
667	});
668	return n;
669	},
670	toArray: function(children) {
671	return mapChildren(children, function(child) {
672	return child;
673	}) \|\| [];
674	},
675	only: function(children) {
676	if (!isValidElement(children))
677	throw Error(
678	"React.Children.only expected to receive a single React element child."
679	);
680	return children;
681	}
682	};
683	exports.Activity = REACT_ACTIVITY_TYPE;
684	exports.Children = fnName;
685	exports.Component = Component;
686	exports.Fragment = REACT_FRAGMENT_TYPE;
687	exports.Profiler = REACT_PROFILER_TYPE;
688	exports.PureComponent = PureComponent;
689	exports.StrictMode = REACT_STRICT_MODE_TYPE;
690	exports.Suspense = REACT_SUSPENSE_TYPE;
691	exports.ViewTransition = REACT_VIEW_TRANSITION_TYPE;
692	exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
693	exports.__COMPILER_RUNTIME = deprecatedAPIs;
694	exports.act = function(callback) {
695	var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
696	actScopeDepth++;
697	var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
698	try {
699	var result = callback();
700	} catch (error) {
701	ReactSharedInternals.thrownErrors.push(error);
702	}
703	if (0 < ReactSharedInternals.thrownErrors.length)
704	throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
705	if (null !== result && "object" === typeof result && "function" === typeof result.then) {
706	var thenable = result;
707	queueSeveralMicrotasks(function() {
708	didAwaitActCall \|\| didWarnNoAwaitAct \|\| (didWarnNoAwaitAct = true, console.error(
709	"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 () => ...);"
710	));
711	});
712	return {
713	then: function(resolve, reject) {
714	didAwaitActCall = true;
715	thenable.then(
716	function(returnValue) {
717	popActScope(prevActQueue, prevActScopeDepth);
718	if (0 === prevActScopeDepth) {
719	try {
720	flushActQueue(queue), enqueueTask(function() {
721	return recursivelyFlushAsyncActWork(
722	returnValue,
723	resolve,
724	reject
725	);
726	});
727	} catch (error$0) {
728	ReactSharedInternals.thrownErrors.push(error$0);
729	}
730	if (0 < ReactSharedInternals.thrownErrors.length) {
731	var _thrownError = aggregateErrors(
732	ReactSharedInternals.thrownErrors
733	);
734	ReactSharedInternals.thrownErrors.length = 0;
735	reject(_thrownError);
736	}
737	} else resolve(returnValue);
738	},
739	function(error) {
740	popActScope(prevActQueue, prevActScopeDepth);
741	0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(
742	ReactSharedInternals.thrownErrors
743	), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
744	}
745	);
746	}
747	};
748	}
749	var returnValue$jscomp$0 = result;
750	popActScope(prevActQueue, prevActScopeDepth);
751	0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
752	didAwaitActCall \|\| didWarnNoAwaitAct \|\| (didWarnNoAwaitAct = true, console.error(
753	"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(() => ...)"
754	));
755	}), ReactSharedInternals.actQueue = null);
756	if (0 < ReactSharedInternals.thrownErrors.length)
757	throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
758	return {
759	then: function(resolve, reject) {
760	didAwaitActCall = true;
761	0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
762	return recursivelyFlushAsyncActWork(
763	returnValue$jscomp$0,
764	resolve,
765	reject
766	);
767	})) : resolve(returnValue$jscomp$0);
768	}
769	};
770	};
771	exports.addTransitionType = addTransitionType;
772	exports.cache = function(fn) {
773	return function() {
774	return fn.apply(null, arguments);
775	};
776	};
777	exports.cacheSignal = function() {
778	return null;
779	};
780	exports.captureOwnerStack = function() {
781	var getCurrentStack = ReactSharedInternals.getCurrentStack;
782	return null === getCurrentStack ? null : getCurrentStack();
783	};
784	exports.cloneElement = function(element, config, children) {
785	if (null === element \|\| void 0 === element)
786	throw Error(
787	"The argument must be a React element, but you passed " + element + "."
788	);
789	var props = assign({}, element.props), key = element.key, owner = element._owner;
790	if (null != config) {
791	var JSCompiler_inline_result;
792	a: {
793	if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
794	config,
795	"ref"
796	).get) && JSCompiler_inline_result.isReactWarning) {
797	JSCompiler_inline_result = false;
798	break a;
799	}
800	JSCompiler_inline_result = void 0 !== config.ref;
801	}
802	JSCompiler_inline_result && (owner = getOwner());
803	hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
804	for (propName in config)
805	!hasOwnProperty.call(config, propName) \|\| "key" === propName \|\| "__self" === propName \|\| "__source" === propName \|\| "ref" === propName && void 0 === config.ref \|\| (props[propName] = config[propName]);
806	}
807	var propName = arguments.length - 2;
808	if (1 === propName) props.children = children;
809	else if (1 < propName) {
810	JSCompiler_inline_result = Array(propName);
811	for (var i = 0; i < propName; i++)
812	JSCompiler_inline_result[i] = arguments[i + 2];
813	props.children = JSCompiler_inline_result;
814	}
815	props = ReactElement(
816	element.type,
817	key,
818	props,
819	owner,
820	element._debugStack,
821	element._debugTask
822	);
823	for (key = 2; key < arguments.length; key++)
824	validateChildKeys(arguments[key]);
825	return props;
826	};
827	exports.createContext = function(defaultValue) {
828	defaultValue = {
829	$$typeof: REACT_CONTEXT_TYPE,
830	_currentValue: defaultValue,
831	_currentValue2: defaultValue,
832	_threadCount: 0,
833	Provider: null,
834	Consumer: null
835	};
836	defaultValue.Provider = defaultValue;
837	defaultValue.Consumer = {
838	$$typeof: REACT_CONSUMER_TYPE,
839	_context: defaultValue
840	};
841	defaultValue._currentRenderer = null;
842	defaultValue._currentRenderer2 = null;
843	return defaultValue;
844	};
845	exports.createElement = function(type, config, children) {
846	for (var i = 2; i < arguments.length; i++)
847	validateChildKeys(arguments[i]);
848	var propName;
849	i = {};
850	var key = null;
851	if (null != config)
852	for (propName in didWarnAboutOldJSXRuntime \|\| !("__self" in config) \|\| "key" in config \|\| (didWarnAboutOldJSXRuntime = true, console.warn(
853	"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"
854	)), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
855	hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
856	var childrenLength = arguments.length - 2;
857	if (1 === childrenLength) i.children = children;
858	else if (1 < childrenLength) {
859	for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++)
860	childArray[_i] = arguments[_i + 2];
861	Object.freeze && Object.freeze(childArray);
862	i.children = childArray;
863	}
864	if (type && type.defaultProps)
865	for (propName in childrenLength = type.defaultProps, childrenLength)
866	void 0 === i[propName] && (i[propName] = childrenLength[propName]);
867	key && defineKeyPropWarningGetter(
868	i,
869	"function" === typeof type ? type.displayName \|\| type.name \|\| "Unknown" : type
870	);
871	(propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++) ? (childArray = Error.stackTraceLimit, Error.stackTraceLimit = 10, childrenLength = Error("react-stack-top-frame"), Error.stackTraceLimit = childArray) : childrenLength = unknownOwnerDebugStack;
872	return ReactElement(
873	type,
874	key,
875	i,
876	getOwner(),
877	childrenLength,
878	propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
879	);
880	};
881	exports.createRef = function() {
882	var refObject = { current: null };
883	Object.seal(refObject);
884	return refObject;
885	};
886	exports.forwardRef = function(render) {
887	null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
888	"forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
889	) : "function" !== typeof render ? console.error(
890	"forwardRef requires a render function but was given %s.",
891	null === render ? "null" : typeof render
892	) : 0 !== render.length && 2 !== render.length && console.error(
893	"forwardRef render functions accept exactly two parameters: props and ref. %s",
894	1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
895	);
896	null != render && null != render.defaultProps && console.error(
897	"forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
898	);
899	var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
900	Object.defineProperty(elementType, "displayName", {
901	enumerable: false,
902	configurable: true,
903	get: function() {
904	return ownName;
905	},
906	set: function(name) {
907	ownName = name;
908	render.name \|\| render.displayName \|\| (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
909	}
910	});
911	return elementType;
912	};
913	exports.isValidElement = isValidElement;
914	exports.lazy = function(ctor) {
915	ctor = { _status: -1, _result: ctor };
916	var lazyType = {
917	$$typeof: REACT_LAZY_TYPE,
918	_payload: ctor,
919	_init: lazyInitializer
920	}, ioInfo = {
921	name: "lazy",
922	start: -1,
923	end: -1,
924	value: null,
925	owner: null,
926	debugStack: Error("react-stack-top-frame"),
927	debugTask: console.createTask ? console.createTask("lazy()") : null
928	};
929	ctor._ioInfo = ioInfo;
930	lazyType._debugInfo = [{ awaited: ioInfo }];
931	return lazyType;
932	};
933	exports.memo = function(type, compare) {
934	null == type && console.error(
935	"memo: The first argument must be a component. Instead received: %s",
936	null === type ? "null" : typeof type
937	);
938	compare = {
939	$$typeof: REACT_MEMO_TYPE,
940	type,
941	compare: void 0 === compare ? null : compare
942	};
943	var ownName;
944	Object.defineProperty(compare, "displayName", {
945	enumerable: false,
946	configurable: true,
947	get: function() {
948	return ownName;
949	},
950	set: function(name) {
951	ownName = name;
952	type.name \|\| type.displayName \|\| (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
953	}
954	});
955	return compare;
956	};
957	exports.startTransition = startTransition;
958	exports.unstable_useCacheRefresh = function() {
959	return resolveDispatcher().useCacheRefresh();
960	};
961	exports.use = function(usable) {
962	return resolveDispatcher().use(usable);
963	};
964	exports.useActionState = function(action, initialState, permalink) {
965	return resolveDispatcher().useActionState(
966	action,
967	initialState,
968	permalink
969	);
970	};
971	exports.useCallback = function(callback, deps) {
972	return resolveDispatcher().useCallback(callback, deps);
973	};
974	exports.useContext = function(Context) {
975	var dispatcher = resolveDispatcher();
976	Context.$$typeof === REACT_CONSUMER_TYPE && console.error(
977	"Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
978	);
979	return dispatcher.useContext(Context);
980	};
981	exports.useDebugValue = function(value, formatterFn) {
982	return resolveDispatcher().useDebugValue(value, formatterFn);
983	};
984	exports.useDeferredValue = function(value, initialValue) {
985	return resolveDispatcher().useDeferredValue(value, initialValue);
986	};
987	exports.useEffect = function(create, deps) {
988	null == create && console.warn(
989	"React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
990	);
991	return resolveDispatcher().useEffect(create, deps);
992	};
993	exports.useEffectEvent = function(callback) {
994	return resolveDispatcher().useEffectEvent(callback);
995	};
996	exports.useId = function() {
997	return resolveDispatcher().useId();
998	};
999	exports.useImperativeHandle = function(ref, create, deps) {
1000	return resolveDispatcher().useImperativeHandle(ref, create, deps);
1001	};
1002	exports.useInsertionEffect = function(create, deps) {
1003	null == create && console.warn(
1004	"React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1005	);
1006	return resolveDispatcher().useInsertionEffect(create, deps);
1007	};
1008	exports.useLayoutEffect = function(create, deps) {
1009	null == create && console.warn(
1010	"React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1011	);
1012	return resolveDispatcher().useLayoutEffect(create, deps);
1013	};
1014	exports.useMemo = function(create, deps) {
1015	return resolveDispatcher().useMemo(create, deps);
1016	};
1017	exports.useOptimistic = function(passthrough, reducer) {
1018	return resolveDispatcher().useOptimistic(passthrough, reducer);
1019	};
1020	exports.useReducer = function(reducer, initialArg, init) {
1021	return resolveDispatcher().useReducer(reducer, initialArg, init);
1022	};
1023	exports.useRef = function(initialValue) {
1024	return resolveDispatcher().useRef(initialValue);
1025	};
1026	exports.useState = function(initialState) {
1027	return resolveDispatcher().useState(initialState);
1028	};
1029	exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
1030	return resolveDispatcher().useSyncExternalStore(
1031	subscribe,
1032	getSnapshot,
1033	getServerSnapshot
1034	);
1035	};
1036	exports.useTransition = function() {
1037	return resolveDispatcher().useTransition();
1038	};
1039	exports.version = "19.3.0";
1040	"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
1041	})();
1042	}
1043	});
1044
1045	// ../react-19/node_modules/react/index.js
1046	var require_react = __commonJS({
1047	"../react-19/node_modules/react/index.js"(exports, module) {
1048	"use strict";
1049	if (false) {
1050	module.exports = null;
1051	} else {
1052	module.exports = require_react_development();
1053	}
1054	}
1055	});
1056
1057	// ../react-19/react.js
1058	var require_react2 = __commonJS({
1059	"../react-19/react.js"(exports, module) {
1060	var { warnCompat: warnCompat2 } = (init_warn_compat(), __toCommonJS(warn_compat_exports));
1061	var SECRET_INTERNALS_KEY = "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED";
1062	var secretInternals = {
1063	ReactCurrentOwner: { current: null },
1064	ReactCurrentDispatcher: { current: null },
1065	ReactDebugCurrentFrame: {
1066	setExtraStackFrame() {
1067	warnCompat2(
1068	"react-secret-internals-setExtraStackFrame",
1069	`\`${SECRET_INTERNALS_KEY}.ReactDebugCurrentFrame.setExtraStackFrame\` was removed in React 19 and is a no-op compatibility shim.`
1070	);
1071	},
1072	getStackAddendum() {
1073	warnCompat2(
1074	"react-secret-internals-getStackAddendum",
1075	`\`${SECRET_INTERNALS_KEY}.ReactDebugCurrentFrame.getStackAddendum\` was removed in React 19 and is a no-op compatibility shim.`
1076	);
1077	return "";
1078	}
1079	}
1080	};
1081	var react = { ...require_react() };
1082	Object.defineProperty(react, SECRET_INTERNALS_KEY, {
1083	enumerable: true,
1084	configurable: true,
1085	get() {
1086	warnCompat2(
1087	"react-secret-internals",
1088	`Accessing \`${SECRET_INTERNALS_KEY}\` was removed in React 19 and is provided by a compatibility shim.`
1089	);
1090	return secretInternals;
1091	}
1092	});
1093	module.exports = react;
1094	}
1095	});
1096	return require_react2();
1097	})();
1098	/*! Bundled license information:
1099
1100	react/cjs/react.development.js:
1101	(**
1102	* @license React
1103	* react.development.js
1104	*
1105	* Copyright (c) Meta Platforms, Inc. and affiliates.
1106	*
1107	* This source code is licensed under the MIT license found in the
1108	* LICENSE file in the root directory of this source tree.
1109	*)
1110	*/
1111