Gutenberg / 23.7.2

Gutenberg v23.7.2

gutenberg / build / scripts / vendors / react-jsx-runtime.js

react-jsx-runtime.js in Gutenberg 23.7.2, at build/scripts/vendors/react-jsx-runtime.js

940 lines 38.9 KB

Raw Download Zip

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