Gutenberg / 23.6.2

Gutenberg v23.6.2

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

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

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