https://app.clariumhealth.com/assets/react-dom-ld7mzddK.js

1import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
2import { t as require_react } from "./react-CCT1erMQ.js";
3var require_scheduler_development = /* @__PURE__ */ __commonJSMin(((exports) => {
4	(function() {
5		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(/* @__PURE__ */ new Error());
6		var enableSchedulerDebugging = false;
7		var enableProfiling = false;
8		var frameYieldMs = 5;
9		function push(heap, node) {
10			var index = heap.length;
11			heap.push(node);
12			siftUp(heap, node, index);
13		}
14		function peek(heap) {
15			return heap.length === 0 ? null : heap[0];
16		}
17		function pop(heap) {
18			if (heap.length === 0) return null;
19			var first = heap[0];
20			var last = heap.pop();
21			if (last !== first) {
22				heap[0] = last;
23				siftDown(heap, last, 0);
24			}
25			return first;
26		}
27		function siftUp(heap, node, i) {
28			var index = i;
29			while (index > 0) {
30				var parentIndex = index - 1 >>> 1;
31				var parent = heap[parentIndex];
32				if (compare(parent, node) > 0) {
33					heap[parentIndex] = node;
34					heap[index] = parent;
35					index = parentIndex;
36				} else return;
37			}
38		}
39		function siftDown(heap, node, i) {
40			var index = i;
41			var length = heap.length;
42			var halfLength = length >>> 1;
43			while (index < halfLength) {
44				var leftIndex = (index + 1) * 2 - 1;
45				var left = heap[leftIndex];
46				var rightIndex = leftIndex + 1;
47				var right = heap[rightIndex];
48				if (compare(left, node) < 0) if (rightIndex < length && compare(right, left) < 0) {
49					heap[index] = right;
50					heap[rightIndex] = node;
51					index = rightIndex;
52				} else {
53					heap[index] = left;
54					heap[leftIndex] = node;
55					index = leftIndex;
56				}
57				else if (rightIndex < length && compare(right, node) < 0) {
58					heap[index] = right;
59					heap[rightIndex] = node;
60					index = rightIndex;
61				} else return;
62			}
63		}
64		function compare(a, b) {
65			var diff = a.sortIndex - b.sortIndex;
66			return diff !== 0 ? diff : a.id - b.id;
67		}
68		var ImmediatePriority = 1;
69		var UserBlockingPriority = 2;
70		var NormalPriority = 3;
71		var LowPriority = 4;
72		var IdlePriority = 5;
73		function markTaskErrored(task, ms) {}
74		if (typeof performance === "object" && typeof performance.now === "function") {
75			var localPerformance = performance;
76			exports.unstable_now = function() {
77				return localPerformance.now();
78			};
79		} else {
80			var localDate = Date;
81			var initialTime = localDate.now();
82			exports.unstable_now = function() {
83				return localDate.now() - initialTime;
84			};
85		}
86		var maxSigned31BitInt = 1073741823;
87		var IMMEDIATE_PRIORITY_TIMEOUT = -1;
88		var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
89		var NORMAL_PRIORITY_TIMEOUT = 5e3;
90		var LOW_PRIORITY_TIMEOUT = 1e4;
91		var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt;
92		var taskQueue = [];
93		var timerQueue = [];
94		var taskIdCounter = 1;
95		var currentTask = null;
96		var currentPriorityLevel = NormalPriority;
97		var isPerformingWork = false;
98		var isHostCallbackScheduled = false;
99		var isHostTimeoutScheduled = false;
100		var localSetTimeout = typeof setTimeout === "function" ? setTimeout : null;
101		var localClearTimeout = typeof clearTimeout === "function" ? clearTimeout : null;
102		var localSetImmediate = typeof setImmediate !== "undefined" ? setImmediate : null;
103		typeof navigator !== "undefined" && navigator.scheduling !== void 0 && navigator.scheduling.isInputPending !== void 0 && navigator.scheduling.isInputPending.bind(navigator.scheduling);
104		function advanceTimers(currentTime) {
105			var timer = peek(timerQueue);
106			while (timer !== null) {
107				if (timer.callback === null) pop(timerQueue);
108				else if (timer.startTime <= currentTime) {
109					pop(timerQueue);
110					timer.sortIndex = timer.expirationTime;
111					push(taskQueue, timer);
112				} else return;
113				timer = peek(timerQueue);
114			}
115		}
116		function handleTimeout(currentTime) {
117			isHostTimeoutScheduled = false;
118			advanceTimers(currentTime);
119			if (!isHostCallbackScheduled) if (peek(taskQueue) !== null) {
120				isHostCallbackScheduled = true;
121				requestHostCallback(flushWork);
122			} else {
123				var firstTimer = peek(timerQueue);
124				if (firstTimer !== null) requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
125			}
126		}
127		function flushWork(hasTimeRemaining, initialTime$1) {
128			isHostCallbackScheduled = false;

129			if (isHostTimeoutScheduled) {
130				isHostTimeoutScheduled = false;
131				cancelHostTimeout();
132			}
133			isPerformingWork = true;
134			var previousPriorityLevel = currentPriorityLevel;
135			try {
136				if (enableProfiling) try {
137					return workLoop(hasTimeRemaining, initialTime$1);
138				} catch (error) {
139					if (currentTask !== null) {
140						var currentTime = exports.unstable_now();
141						markTaskErrored(currentTask, currentTime);
142						currentTask.isQueued = false;
143					}
144					throw error;
145				}
146				else return workLoop(hasTimeRemaining, initialTime$1);
147			} finally {
148				currentTask = null;
149				currentPriorityLevel = previousPriorityLevel;
150				isPerformingWork = false;
151			}
152		}
153		function workLoop(hasTimeRemaining, initialTime$1) {
154			var currentTime = initialTime$1;
155			advanceTimers(currentTime);
156			currentTask = peek(taskQueue);
157			while (currentTask !== null && !enableSchedulerDebugging) {
158				if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) break;
159				var callback = currentTask.callback;
160				if (typeof callback === "function") {
161					currentTask.callback = null;
162					currentPriorityLevel = currentTask.priorityLevel;
163					var continuationCallback = callback(currentTask.expirationTime <= currentTime);
164					currentTime = exports.unstable_now();
165					if (typeof continuationCallback === "function") currentTask.callback = continuationCallback;
166					else if (currentTask === peek(taskQueue)) pop(taskQueue);
167					advanceTimers(currentTime);
168				} else pop(taskQueue);
169				currentTask = peek(taskQueue);
170			}
171			if (currentTask !== null) return true;
172			else {
173				var firstTimer = peek(timerQueue);
174				if (firstTimer !== null) requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
175				return false;
176			}
177		}
178		function unstable_runWithPriority(priorityLevel, eventHandler) {
179			switch (priorityLevel) {
180				case ImmediatePriority:
181				case UserBlockingPriority:
182				case NormalPriority:
183				case LowPriority:
184				case IdlePriority: break;
185				default: priorityLevel = NormalPriority;
186			}
187			var previousPriorityLevel = currentPriorityLevel;
188			currentPriorityLevel = priorityLevel;
189			try {
190				return eventHandler();
191			} finally {
192				currentPriorityLevel = previousPriorityLevel;
193			}
194		}
195		function unstable_next(eventHandler) {
196			var priorityLevel;
197			switch (currentPriorityLevel) {
198				case ImmediatePriority:
199				case UserBlockingPriority:
200				case NormalPriority:
201					priorityLevel = NormalPriority;
202					break;
203				default:
204					priorityLevel = currentPriorityLevel;
205					break;
206			}
207			var previousPriorityLevel = currentPriorityLevel;
208			currentPriorityLevel = priorityLevel;
209			try {
210				return eventHandler();
211			} finally {
212				currentPriorityLevel = previousPriorityLevel;
213			}
214		}
215		function unstable_wrapCallback(callback) {
216			var parentPriorityLevel = currentPriorityLevel;
217			return function() {
218				var previousPriorityLevel = currentPriorityLevel;
219				currentPriorityLevel = parentPriorityLevel;
220				try {
221					return callback.apply(this, arguments);
222				} finally {
223					currentPriorityLevel = previousPriorityLevel;
224				}
225			};
226		}
227		function unstable_scheduleCallback(priorityLevel, callback, options) {
228			var currentTime = exports.unstable_now();
229			var startTime$1;
230			if (typeof options === "object" && options !== null) {
231				var delay = options.delay;
232				if (typeof delay === "number" && delay > 0) startTime$1 = currentTime + delay;
233				else startTime$1 = currentTime;
234			} else startTime$1 = currentTime;
235			var timeout;
236			switch (priorityLevel) {
237				case ImmediatePriority:
238					timeout = IMMEDIATE_PRIORITY_TIMEOUT;

239					break;
240				case UserBlockingPriority:
241					timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
242					break;
243				case IdlePriority:
244					timeout = IDLE_PRIORITY_TIMEOUT;
245					break;
246				case LowPriority:
247					timeout = LOW_PRIORITY_TIMEOUT;
248					break;
249				case NormalPriority:
250				default:
251					timeout = NORMAL_PRIORITY_TIMEOUT;
252					break;
253			}
254			var expirationTime = startTime$1 + timeout;
255			var newTask = {
256				id: taskIdCounter++,
257				callback,
258				priorityLevel,
259				startTime: startTime$1,
260				expirationTime,
261				sortIndex: -1
262			};
263			if (startTime$1 > currentTime) {
264				newTask.sortIndex = startTime$1;
265				push(timerQueue, newTask);
266				if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
267					if (isHostTimeoutScheduled) cancelHostTimeout();
268					else isHostTimeoutScheduled = true;
269					requestHostTimeout(handleTimeout, startTime$1 - currentTime);
270				}
271			} else {
272				newTask.sortIndex = expirationTime;
273				push(taskQueue, newTask);
274				if (!isHostCallbackScheduled && !isPerformingWork) {
275					isHostCallbackScheduled = true;
276					requestHostCallback(flushWork);
277				}
278			}
279			return newTask;
280		}
281		function unstable_pauseExecution() {}
282		function unstable_continueExecution() {
283			if (!isHostCallbackScheduled && !isPerformingWork) {
284				isHostCallbackScheduled = true;
285				requestHostCallback(flushWork);
286			}
287		}
288		function unstable_getFirstCallbackNode() {
289			return peek(taskQueue);
290		}
291		function unstable_cancelCallback(task) {
292			task.callback = null;
293		}
294		function unstable_getCurrentPriorityLevel() {
295			return currentPriorityLevel;
296		}
297		var isMessageLoopRunning = false;
298		var scheduledHostCallback = null;
299		var taskTimeoutID = -1;
300		var frameInterval = frameYieldMs;
301		var startTime = -1;
302		function shouldYieldToHost() {
303			if (exports.unstable_now() - startTime < frameInterval) return false;
304			return true;
305		}
306		function requestPaint() {}
307		function forceFrameRate(fps) {
308			if (fps < 0 || fps > 125) {
309				console["error"]("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported");
310				return;
311			}
312			if (fps > 0) frameInterval = Math.floor(1e3 / fps);
313			else frameInterval = frameYieldMs;
314		}
315		var performWorkUntilDeadline = function() {
316			if (scheduledHostCallback !== null) {
317				var currentTime = exports.unstable_now();
318				startTime = currentTime;
319				var hasTimeRemaining = true;
320				var hasMoreWork = true;
321				try {
322					hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);
323				} finally {
324					if (hasMoreWork) schedulePerformWorkUntilDeadline();
325					else {
326						isMessageLoopRunning = false;
327						scheduledHostCallback = null;
328					}
329				}
330			} else isMessageLoopRunning = false;
331		};
332		var schedulePerformWorkUntilDeadline;
333		if (typeof localSetImmediate === "function") schedulePerformWorkUntilDeadline = function() {
334			localSetImmediate(performWorkUntilDeadline);
335		};
336		else if (typeof MessageChannel !== "undefined") {
337			var channel = new MessageChannel();
338			var port = channel.port2;
339			channel.port1.onmessage = performWorkUntilDeadline;
340			schedulePerformWorkUntilDeadline = function() {
341				port.postMessage(null);
342			};
343		} else schedulePerformWorkUntilDeadline = function() {
344			localSetTimeout(performWorkUntilDeadline, 0);
345		};
346		function requestHostCallback(callback) {
347			scheduledHostCallback = callback;
348			if (!isMessageLoopRunning) {
349				isMessageLoopRunning = true;
350				schedulePerformWorkUntilDeadline();
351			}
352		}
353		function requestHostTimeout(callback, ms) {
354			taskTimeoutID = localSetTimeout(function() {
355				callback(exports.unstable_now());
356			}, ms);
357		}
358		function cancelHostTimeout() {
359			localClearTimeout(taskTimeoutID);
360			taskTimeoutID = -1;
361		}
362		var unstable_requestPaint = requestPaint;
363		var unstable_Profiling = null;
364		exports.unstable_IdlePriority = IdlePriority;
365		exports.unstable_ImmediatePriority = ImmediatePriority;
366		exports.unstable_LowPriority = LowPriority;
367		exports.unstable_NormalPriority = NormalPriority;
368		exports.unstable_Profiling = unstable_Profiling;
369		exports.unstable_UserBlockingPriority = UserBlockingPriority;
370		exports.unstable_cancelCallback = unstable_cancelCallback;
371		exports.unstable_continueExecution = unstable_continueExecution;
372		exports.unstable_forceFrameRate = forceFrameRate;
373		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
374		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
375		exports.unstable_next = unstable_next;
376		exports.unstable_pauseExecution = unstable_pauseExecution;
377		exports.unstable_requestPaint = unstable_requestPaint;
378		exports.unstable_runWithPriority = unstable_runWithPriority;
379		exports.unstable_scheduleCallback = unstable_scheduleCallback;
380		exports.unstable_shouldYield = shouldYieldToHost;
381		exports.unstable_wrapCallback = unstable_wrapCallback;
382		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(/* @__PURE__ */ new Error());
383	})();
384}));
385var require_scheduler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
386	module.exports = require_scheduler_development();
387}));
388var require_react_dom_development = /* @__PURE__ */ __commonJSMin(((exports) => {
389	(function() {
390		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(/* @__PURE__ */ new Error());
391		var React = require_react();
392		var Scheduler = require_scheduler();

393		var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
394		var suppressWarning = false;
395		function setSuppressWarning(newSuppressWarning) {
396			suppressWarning = newSuppressWarning;
397		}
398		function warn(format) {
399			if (!suppressWarning) {
400				for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
401				printWarning("warn", format, args);
402			}
403		}
404		function error(format) {
405			if (!suppressWarning) {
406				for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
407				printWarning("error", format, args);
408			}
409		}
410		function printWarning(level, format, args) {
411			var stack = ReactSharedInternals.ReactDebugCurrentFrame.getStackAddendum();
412			if (stack !== "") {
413				format += "%s";
414				args = args.concat([stack]);
415			}
416			var argsWithFormat = args.map(function(item) {
417				return String(item);
418			});
419			argsWithFormat.unshift("Warning: " + format);
420			Function.prototype.apply.call(console[level], console, argsWithFormat);
421		}
422		var FunctionComponent = 0;
423		var ClassComponent = 1;
424		var IndeterminateComponent = 2;
425		var HostRoot = 3;
426		var HostPortal = 4;
427		var HostComponent = 5;
428		var HostText = 6;
429		var Fragment = 7;
430		var Mode = 8;
431		var ContextConsumer = 9;
432		var ContextProvider = 10;
433		var ForwardRef = 11;
434		var Profiler = 12;
435		var SuspenseComponent = 13;
436		var MemoComponent = 14;
437		var SimpleMemoComponent = 15;
438		var LazyComponent = 16;
439		var IncompleteClassComponent = 17;
440		var DehydratedFragment = 18;
441		var SuspenseListComponent = 19;
442		var ScopeComponent = 21;
443		var OffscreenComponent = 22;
444		var LegacyHiddenComponent = 23;
445		var CacheComponent = 24;
446		var TracingMarkerComponent = 25;
447		var enableClientRenderFallbackOnTextMismatch = true;
448		var enableNewReconciler = false;
449		var enableLazyContextPropagation = false;
450		var enableLegacyHidden = false;
451		var enableSuspenseAvoidThisFallback = false;
452		var disableCommentsAsDOMContainers = true;
453		var enableCustomElementPropertySupport = false;
454		var warnAboutStringRefs = true;
455		var enableSchedulingProfiler = true;
456		var enableProfilerTimer = true;
457		var enableProfilerCommitHooks = true;
458		var allNativeEvents = /* @__PURE__ */ new Set();
459		var registrationNameDependencies = {};
460		var possibleRegistrationNames = {};
461		function registerTwoPhaseEvent(registrationName, dependencies) {
462			registerDirectEvent(registrationName, dependencies);
463			registerDirectEvent(registrationName + "Capture", dependencies);
464		}
465		function registerDirectEvent(registrationName, dependencies) {
466			if (registrationNameDependencies[registrationName]) error("EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.", registrationName);
467			registrationNameDependencies[registrationName] = dependencies;
468			var lowerCasedName = registrationName.toLowerCase();
469			possibleRegistrationNames[lowerCasedName] = registrationName;
470			if (registrationName === "onDoubleClick") possibleRegistrationNames.ondblclick = registrationName;
471			for (var i = 0; i < dependencies.length; i++) allNativeEvents.add(dependencies[i]);
472		}
473		var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
474		var hasOwnProperty = Object.prototype.hasOwnProperty;
475		function typeName(value) {
476			return typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
477		}
478		function willCoercionThrow(value) {
479			try {
480				testStringCoercion(value);
481				return false;
482			} catch (e) {
483				return true;
484			}
485		}
486		function testStringCoercion(value) {
487			return "" + value;
488		}
489		function checkAttributeStringCoercion(value, attributeName) {
490			if (willCoercionThrow(value)) {
491				error("The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before before using it here.", attributeName, typeName(value));
492				return testStringCoercion(value);
493			}
494		}
495		function checkKeyStringCoercion(value) {
496			if (willCoercionThrow(value)) {
497				error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
498				return testStringCoercion(value);
499			}
500		}
501		function checkPropStringCoercion(value, propName) {
502			if (willCoercionThrow(value)) {
503				error("The provided `%s` prop is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(value));
504				return testStringCoercion(value);
505			}
506		}
507		function checkCSSPropertyStringCoercion(value, propName) {
508			if (willCoercionThrow(value)) {
509				error("The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(value));
510				return testStringCoercion(value);
511			}
512		}
513		function checkHtmlStringCoercion(value) {
514			if (willCoercionThrow(value)) {
515				error("The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
516				return testStringCoercion(value);
517			}
518		}
519		function checkFormFieldValueStringCoercion(value) {
520			if (willCoercionThrow(value)) {
521				error("Form field values (value, checked, defaultValue, or defaultChecked props) must be strings, not %s. This value must be coerced to a string before before using it here.", typeName(value));
522				return testStringCoercion(value);
523			}
524		}
525		var RESERVED = 0;
526		var STRING = 1;
527		var BOOLEANISH_STRING = 2;
528		var BOOLEAN = 3;
529		var OVERLOADED_BOOLEAN = 4;
530		var NUMERIC = 5;
531		var POSITIVE_NUMERIC = 6;
532		var ATTRIBUTE_NAME_START_CHAR = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u

532037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
533		var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
534		var VALID_ATTRIBUTE_NAME_REGEX = /* @__PURE__ */ new RegExp("^[" + ATTRIBUTE_NAME_START_CHAR + "][" + ATTRIBUTE_NAME_CHAR + "]*$");
535		var illegalAttributeNameCache = {};
536		var validatedAttributeNameCache = {};
537		function isAttributeNameSafe(attributeName) {
538			if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) return true;
539			if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) return false;
540			if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
541				validatedAttributeNameCache[attributeName] = true;
542				return true;
543			}
544			illegalAttributeNameCache[attributeName] = true;
545			error("Invalid attribute name: `%s`", attributeName);
546			return false;
547		}
548		function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) {
549			if (propertyInfo !== null) return propertyInfo.type === RESERVED;
550			if (isCustomComponentTag) return false;
551			if (name.length > 2 && (name[0] === "o" || name[0] === "O") && (name[1] === "n" || name[1] === "N")) return true;
552			return false;
553		}
554		function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) {
555			if (propertyInfo !== null && propertyInfo.type === RESERVED) return false;
556			switch (typeof value) {
557				case "function":
558				case "symbol": return true;
559				case "boolean":
560					if (isCustomComponentTag) return false;
561					if (propertyInfo !== null) return !propertyInfo.acceptsBooleans;
562					else {
563						var prefix$1 = name.toLowerCase().slice(0, 5);
564						return prefix$1 !== "data-" && prefix$1 !== "aria-";
565					}
566				default: return false;
567			}
568		}
569		function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) {
570			if (value === null || typeof value === "undefined") return true;
571			if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) return true;
572			if (isCustomComponentTag) return false;
573			if (propertyInfo !== null) switch (propertyInfo.type) {
574				case BOOLEAN: return !value;
575				case OVERLOADED_BOOLEAN: return value === false;
576				case NUMERIC: return isNaN(value);
577				case POSITIVE_NUMERIC: return isNaN(value) || value < 1;
578			}
579			return false;
580		}
581		function getPropertyInfo(name) {
582			return properties.hasOwnProperty(name) ? properties[name] : null;
583		}
584		function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL$1, removeEmptyString) {
585			this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN;
586			this.attributeName = attributeName;
587			this.attributeNamespace = attributeNamespace;
588			this.mustUseProperty = mustUseProperty;
589			this.propertyName = name;
590			this.type = type;
591			this.sanitizeURL = sanitizeURL$1;
592			this.removeEmptyString = removeEmptyString;
593		}
594		var properties = {};
595		[
596			"children",
597			"dangerouslySetInnerHTML",
598			"defaultValue",
599			"defaultChecked",
600			"innerHTML",
601			"suppressContentEditableWarning",
602			"suppressHydrationWarning",
603			"style"
604		].forEach(function(name) {
605			properties[name] = new PropertyInfoRecord(name, RESERVED, false, name, null, false, false);
606		});
607		[
608			["acceptCharset", "accept-charset"],
609			["className", "class"],
610			["htmlFor", "for"],
611			["httpEquiv", "http-equiv"]
612		].forEach(function(_ref) {
613			var name = _ref[0], attributeName = _ref[1];
614			properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, null, false, false);
615		});
616		[
617			"contentEditable",
618			"draggable",
619			"spellCheck",
620			"value"
621		].forEach(function(name) {
622			properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, name.toLowerCase(), null, false, false);
623		});
624		[
625			"autoReverse",
626			"externalResourcesRequired",
627			"focusable",
628			"preserveAlpha"
629		].forEach(function(name) {
630			properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, name, null, false, false);
631		});
632		[
633			"allowFullScreen",
634			"async",
635			"autoFocus",
636			"autoPlay",
637			"controls",
638			"default",
639			"defer",
640			"disabled",
641			"disablePictureInPicture",
642			"disableRemotePlayback",
643			"formNoValidate",
644			"hidden",
645			"loop",
646			"noModule",
647			"noValidate",
648			"open",

649			"playsInline",
650			"readOnly",
651			"required",
652			"reversed",
653			"scoped",
654			"seamless",
655			"itemScope"
656		].forEach(function(name) {
657			properties[name] = new PropertyInfoRecord(name, BOOLEAN, false, name.toLowerCase(), null, false, false);
658		});
659		[
660			"checked",
661			"multiple",
662			"muted",
663			"selected"
664		].forEach(function(name) {
665			properties[name] = new PropertyInfoRecord(name, BOOLEAN, true, name, null, false, false);
666		});
667		["capture", "download"].forEach(function(name) {
668			properties[name] = new PropertyInfoRecord(name, OVERLOADED_BOOLEAN, false, name, null, false, false);
669		});
670		[
671			"cols",
672			"rows",
673			"size",
674			"span"
675		].forEach(function(name) {
676			properties[name] = new PropertyInfoRecord(name, POSITIVE_NUMERIC, false, name, null, false, false);
677		});
678		["rowSpan", "start"].forEach(function(name) {
679			properties[name] = new PropertyInfoRecord(name, NUMERIC, false, name.toLowerCase(), null, false, false);
680		});
681		var CAMELIZE = /[\-\:]([a-z])/g;
682		var capitalize = function(token) {
683			return token[1].toUpperCase();
684		};
685		[
686			"accent-height",
687			"alignment-baseline",
688			"arabic-form",
689			"baseline-shift",
690			"cap-height",
691			"clip-path",
692			"clip-rule",
693			"color-interpolation",
694			"color-interpolation-filters",
695			"color-profile",
696			"color-rendering",
697			"dominant-baseline",
698			"enable-background",
699			"fill-opacity",
700			"fill-rule",
701			"flood-color",
702			"flood-opacity",
703			"font-family",
704			"font-size",
705			"font-size-adjust",
706			"font-stretch",
707			"font-style",
708			"font-variant",
709			"font-weight",
710			"glyph-name",
711			"glyph-orientation-horizontal",
712			"glyph-orientation-vertical",
713			"horiz-adv-x",
714			"horiz-origin-x",
715			"image-rendering",
716			"letter-spacing",
717			"lighting-color",
718			"marker-end",
719			"marker-mid",
720			"marker-start",
721			"overline-position",
722			"overline-thickness",
723			"paint-order",
724			"panose-1",
725			"pointer-events",
726			"rendering-intent",
727			"shape-rendering",
728			"stop-color",
729			"stop-opacity",
730			"strikethrough-position",
731			"strikethrough-thickness",
732			"stroke-dasharray",
733			"stroke-dashoffset",
734			"stroke-linecap",
735			"stroke-linejoin",
736			"stroke-miterlimit",
737			"stroke-opacity",
738			"stroke-width",
739			"text-anchor",
740			"text-decoration",
741			"text-rendering",
742			"underline-position",
743			"underline-thickness",
744			"unicode-bidi",
745			"unicode-range",
746			"units-per-em",
747			"v-alphabetic",
748			"v-hanging",
749			"v-ideographic",
750			"v-mathematical",
751			"vector-effect",
752			"vert-adv-y",
753			"vert-origin-x",
754			"vert-origin-y",
755			"word-spacing",
756			"writing-mode",
757			"xmlns:xlink",
758			"x-height"
759		].forEach(function(attributeName) {
760			var name = attributeName.replace(CAMELIZE, capitalize);
761			properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, null, false, false);
762		});
763		[
764			"xlink:actuate",
765			"xlink:arcrole",
766			"xlink:role",
767			"xlink:show",
768			"xlink:title",
769			"xlink:type"
770		].forEach(function(attributeName) {
771			var name = attributeName.replace(CAMELIZE, capitalize);
772			properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, "http://www.w3.org/1999/xlink", false, false);
773		});
774		[
775			"xml:base",
776			"xml:lang",
777			"xml:space"
778		].forEach(function(attributeName) {
779			var name = attributeName.replace(CAMELIZE, capitalize);
780			properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, "http://www.w3.org/XML/1998/namespace", false, false);
781		});
782		["tabIndex", "crossOrigin"].forEach(function(attributeName) {
783			properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, attributeName.toLowerCase(), null, false, false);
784		});
785		var xlinkHref = "xlinkHref";
786		properties[xlinkHref] = new PropertyInfoRecord("xlinkHref", STRING, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false);
787		[
788			"src",
789			"href",
790			"action",
791			"formAction"
792		].forEach(function(attributeName) {
793			properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, attributeName.toLowerCase(), null, true, true);
794		});
795		var isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i;
796		var didWarn = false;

797		function sanitizeURL(url) {
798			if (!didWarn && isJavaScriptProtocol.test(url)) {
799				didWarn = true;
800				error("A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML try using dangerouslySetInnerHTML instead. React was passed %s.", JSON.stringify(url));
801			}
802		}
803		function getValueForProperty(node, name, expected, propertyInfo) {
804			if (propertyInfo.mustUseProperty) return node[propertyInfo.propertyName];
805			else {
806				checkAttributeStringCoercion(expected, name);
807				if (propertyInfo.sanitizeURL) sanitizeURL("" + expected);
808				var attributeName = propertyInfo.attributeName;
809				var stringValue = null;
810				if (propertyInfo.type === OVERLOADED_BOOLEAN) {
811					if (node.hasAttribute(attributeName)) {
812						var value = node.getAttribute(attributeName);
813						if (value === "") return true;
814						if (shouldRemoveAttribute(name, expected, propertyInfo, false)) return value;
815						if (value === "" + expected) return expected;
816						return value;
817					}
818				} else if (node.hasAttribute(attributeName)) {
819					if (shouldRemoveAttribute(name, expected, propertyInfo, false)) return node.getAttribute(attributeName);
820					if (propertyInfo.type === BOOLEAN) return expected;
821					stringValue = node.getAttribute(attributeName);
822				}
823				if (shouldRemoveAttribute(name, expected, propertyInfo, false)) return stringValue === null ? expected : stringValue;
824				else if (stringValue === "" + expected) return expected;
825				else return stringValue;
826			}
827		}
828		function getValueForAttribute(node, name, expected, isCustomComponentTag) {
829			if (!isAttributeNameSafe(name)) return;
830			if (!node.hasAttribute(name)) return expected === void 0 ? void 0 : null;
831			var value = node.getAttribute(name);
832			checkAttributeStringCoercion(expected, name);
833			if (value === "" + expected) return expected;
834			return value;
835		}
836		function setValueForProperty(node, name, value, isCustomComponentTag) {
837			var propertyInfo = getPropertyInfo(name);
838			if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) return;
839			if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) value = null;
840			if (isCustomComponentTag || propertyInfo === null) {
841				if (isAttributeNameSafe(name)) {
842					var _attributeName = name;
843					if (value === null) node.removeAttribute(_attributeName);
844					else {
845						checkAttributeStringCoercion(value, name);
846						node.setAttribute(_attributeName, "" + value);
847					}
848				}
849				return;
850			}
851			if (propertyInfo.mustUseProperty) {
852				var propertyName = propertyInfo.propertyName;
853				if (value === null) node[propertyName] = propertyInfo.type === BOOLEAN ? false : "";
854				else node[propertyName] = value;
855				return;
856			}
857			var attributeName = propertyInfo.attributeName, attributeNamespace = propertyInfo.attributeNamespace;
858			if (value === null) node.removeAttribute(attributeName);
859			else {
860				var _type = propertyInfo.type;
861				var attributeValue;
862				if (_type === BOOLEAN || _type === OVERLOADED_BOOLEAN && value === true) attributeValue = "";
863				else {
864					checkAttributeStringCoercion(value, attributeName);
865					attributeValue = "" + value;
866					if (propertyInfo.sanitizeURL) sanitizeURL(attributeValue.toString());
867				}
868				if (attributeNamespace) node.setAttributeNS(attributeNamespace, attributeName, attributeValue);
869				else node.setAttribute(attributeName, attributeValue);
870			}
871		}
872		var REACT_ELEMENT_TYPE = Symbol.for("react.element");
873		var REACT_PORTAL_TYPE = Symbol.for("react.portal");
874		var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
875		var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
876		var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
877		var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
878		var REACT_CONTEXT_TYPE = Symbol.for("react.context");
879		var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
880		var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
881		var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
882		var REACT_MEMO_TYPE = Symbol.for("react.memo");
883		var REACT_LAZY_TYPE = Symbol.for("react.lazy");
884		var REACT_SCOPE_TYPE = Symbol.for("react.scope");
885		var REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode");
886		var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
887		var REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden");
888		var REACT_CACHE_TYPE = Symbol.for("react.cache");
889		var REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker");
890		var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
891		var FAUX_ITERATOR_SYMBOL = "@@iterator";
892		function getIteratorFn(maybeIterable) {
893			if (maybeIterable === null || typeof maybeIterable !== "object") return null;
894			var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
895			if (typeof maybeIterator === "function") return maybeIterator;
896			return null;
897		}
898		var assign = Object.assign;
899		var disabledDepth = 0;
900		var prevLog;
901		var prevInfo;
902		var prevWarn;
903		var prevError;
904		var prevGroup;
905		var prevGroupCollapsed;
906		var prevGroupEnd;
907		function disabledLog() {}
908		disabledLog.__reactDisabledLog = true;
909		function disableLogs() {
910			if (disabledDepth === 0) {
911				prevLog = console.log;
912				prevInfo = console.info;
913				prevWarn = console.warn;
914				prevError = console.error;
915				prevGroup = console.group;
916				prevGroupCollapsed = console.groupCollapsed;
917				prevGroupEnd = console.groupEnd;
918				var props = {
919					configurable: true,
920					enumerable: true,
921					value: disabledLog,
922					writable: true
923				};
924				Object.defineProperties(console, {
925					info: props,
926					log: props,
927					warn: props,
928					error: props,
929					group: props,
930					groupCollapsed: props,
931					groupEnd: props
932				});
933			}
934			disabledDepth++;
935		}
936		function reenableLogs() {
937			disabledDepth--;
938			if (disabledDepth === 0) {
939				var props = {
940					configurable: true,
941					enumerable: true,
942					writable: true
943				};
944				Object.defineProperties(console, {
945					log: assign({}, props, { value: prevLog }),
946					info: assign({}, props, { value: prevInfo }),
947					warn: assign({}, props, { value: prevWarn }),
948					error: assign({}, props, { value: prevError }),
949					group: assign({}, props, { value: prevGroup }),
950					groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
951					groupEnd: assign({}, props, { value: prevGroupEnd })
952				});
953			}
954			if (disabledDepth < 0) error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
955		}
956		var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
957		var prefix;
958		function describeBuiltInComponentFrame(name, source, ownerFn) {
959			if (prefix === void 0) try {
960				throw Error();
961			} catch (x) {
962				var match = x.stack.trim().match(/\n( *(at )?)/);
963				prefix = match && match[1] || "";
964			}
965			return "\n" + prefix + name;
966		}
967		var reentry = false;

968		var componentFrameCache = new (typeof WeakMap === "function" ? WeakMap : Map)();
969		function describeNativeComponentFrame(fn, construct) {
970			if (!fn || reentry) return "";
971			var frame = componentFrameCache.get(fn);
972			if (frame !== void 0) return frame;
973			var control;
974			reentry = true;
975			var previousPrepareStackTrace = Error.prepareStackTrace;
976			Error.prepareStackTrace = void 0;
977			var previousDispatcher = ReactCurrentDispatcher.current;
978			ReactCurrentDispatcher.current = null;
979			disableLogs();
980			try {
981				if (construct) {
982					var Fake = function() {
983						throw Error();
984					};
985					Object.defineProperty(Fake.prototype, "props", { set: function() {
986						throw Error();
987					} });
988					if (typeof Reflect === "object" && Reflect.construct) {
989						try {
990							Reflect.construct(Fake, []);
991						} catch (x) {
992							control = x;
993						}
994						Reflect.construct(fn, [], Fake);
995					} else {
996						try {
997							Fake.call();
998						} catch (x) {
999							control = x;
1000						}
1001						fn.call(Fake.prototype);
1002					}
1003				} else {
1004					try {
1005						throw Error();
1006					} catch (x) {
1007						control = x;
1008					}
1009					fn();
1010				}
1011			} catch (sample) {
1012				if (sample && control && typeof sample.stack === "string") {
1013					var sampleLines = sample.stack.split("\n");
1014					var controlLines = control.stack.split("\n");
1015					var s = sampleLines.length - 1;
1016					var c = controlLines.length - 1;
1017					while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) c--;
1018					for (; s >= 1 && c >= 0; s--, c--) if (sampleLines[s] !== controlLines[c]) {
1019						if (s !== 1 || c !== 1) do {
1020							s--;
1021							c--;
1022							if (c < 0 || sampleLines[s] !== controlLines[c]) {
1023								var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
1024								if (fn.displayName && _frame.includes("<anonymous>")) _frame = _frame.replace("<anonymous>", fn.displayName);
1025								if (typeof fn === "function") componentFrameCache.set(fn, _frame);
1026								return _frame;
1027							}
1028						} while (s >= 1 && c >= 0);
1029						break;
1030					}
1031				}
1032			} finally {
1033				reentry = false;
1034				ReactCurrentDispatcher.current = previousDispatcher;
1035				reenableLogs();
1036				Error.prepareStackTrace = previousPrepareStackTrace;
1037			}
1038			var name = fn ? fn.displayName || fn.name : "";
1039			var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
1040			if (typeof fn === "function") componentFrameCache.set(fn, syntheticFrame);
1041			return syntheticFrame;
1042		}
1043		function describeClassComponentFrame(ctor, source, ownerFn) {
1044			return describeNativeComponentFrame(ctor, true);
1045		}
1046		function describeFunctionComponentFrame(fn, source, ownerFn) {
1047			return describeNativeComponentFrame(fn, false);
1048		}
1049		function shouldConstruct(Component) {
1050			var prototype = Component.prototype;
1051			return !!(prototype && prototype.isReactComponent);
1052		}
1053		function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
1054			if (type == null) return "";
1055			if (typeof type === "function") return describeNativeComponentFrame(type, shouldConstruct(type));
1056			if (typeof type === "string") return describeBuiltInComponentFrame(type);
1057			switch (type) {
1058				case REACT_SUSPENSE_TYPE: return describeBuiltInComponentFrame("Suspense");
1059				case REACT_SUSPENSE_LIST_TYPE: return describeBuiltInComponentFrame("SuspenseList");
1060			}
1061			if (typeof type === "object") switch (type.$$typeof) {
1062				case REACT_FORWARD_REF_TYPE: return describeFunctionComponentFrame(type.render);
1063				case REACT_MEMO_TYPE: return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
1064				case REACT_LAZY_TYPE:
1065					var lazyComponent = type;
1066					var payload = lazyComponent._payload;
1067					var init = lazyComponent._init;
1068					try {
1069						return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
1070					} catch (x) {}
1071			}
1072			return "";
1073		}
1074		function describeFiber(fiber) {
1075			fiber._debugOwner && fiber._debugOwner.type;
1076			fiber._debugSource;
1077			switch (fiber.tag) {
1078				case HostComponent: return describeBuiltInComponentFrame(fiber.type);
1079				case LazyComponent: return describeBuiltInComponentFrame("Lazy");
1080				case SuspenseComponent: return describeBuiltInComponentFrame("Suspense");
1081				case SuspenseListComponent: return describeBuiltInComponentFrame("SuspenseList");
1082				case FunctionComponent:

1083				case IndeterminateComponent:
1084				case SimpleMemoComponent: return describeFunctionComponentFrame(fiber.type);
1085				case ForwardRef: return describeFunctionComponentFrame(fiber.type.render);
1086				case ClassComponent: return describeClassComponentFrame(fiber.type);
1087				default: return "";
1088			}
1089		}
1090		function getStackByFiberInDevAndProd(workInProgress$1) {
1091			try {
1092				var info = "";
1093				var node = workInProgress$1;
1094				do {
1095					info += describeFiber(node);
1096					node = node.return;
1097				} while (node);
1098				return info;
1099			} catch (x) {
1100				return "\nError generating stack: " + x.message + "\n" + x.stack;
1101			}
1102		}
1103		function getWrappedName(outerType, innerType, wrapperName) {
1104			var displayName = outerType.displayName;
1105			if (displayName) return displayName;
1106			var functionName = innerType.displayName || innerType.name || "";
1107			return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
1108		}
1109		function getContextName(type) {
1110			return type.displayName || "Context";
1111		}
1112		function getComponentNameFromType(type) {
1113			if (type == null) return null;
1114			if (typeof type.tag === "number") error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
1115			if (typeof type === "function") return type.displayName || type.name || null;
1116			if (typeof type === "string") return type;
1117			switch (type) {
1118				case REACT_FRAGMENT_TYPE: return "Fragment";
1119				case REACT_PORTAL_TYPE: return "Portal";
1120				case REACT_PROFILER_TYPE: return "Profiler";
1121				case REACT_STRICT_MODE_TYPE: return "StrictMode";
1122				case REACT_SUSPENSE_TYPE: return "Suspense";
1123				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
1124			}
1125			if (typeof type === "object") switch (type.$$typeof) {
1126				case REACT_CONTEXT_TYPE: return getContextName(type) + ".Consumer";
1127				case REACT_PROVIDER_TYPE: return getContextName(type._context) + ".Provider";
1128				case REACT_FORWARD_REF_TYPE: return getWrappedName(type, type.render, "ForwardRef");
1129				case REACT_MEMO_TYPE:
1130					var outerName = type.displayName || null;
1131					if (outerName !== null) return outerName;
1132					return getComponentNameFromType(type.type) || "Memo";
1133				case REACT_LAZY_TYPE:
1134					var lazyComponent = type;
1135					var payload = lazyComponent._payload;
1136					var init = lazyComponent._init;
1137					try {
1138						return getComponentNameFromType(init(payload));
1139					} catch (x) {
1140						return null;
1141					}
1142			}
1143			return null;
1144		}
1145		function getWrappedName$1(outerType, innerType, wrapperName) {
1146			var functionName = innerType.displayName || innerType.name || "";
1147			return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
1148		}
1149		function getContextName$1(type) {
1150			return type.displayName || "Context";
1151		}
1152		function getComponentNameFromFiber(fiber) {
1153			var tag = fiber.tag, type = fiber.type;
1154			switch (tag) {
1155				case CacheComponent: return "Cache";
1156				case ContextConsumer: return getContextName$1(type) + ".Consumer";
1157				case ContextProvider: return getContextName$1(type._context) + ".Provider";
1158				case DehydratedFragment: return "DehydratedFragment";
1159				case ForwardRef: return getWrappedName$1(type, type.render, "ForwardRef");
1160				case Fragment: return "Fragment";
1161				case HostComponent: return type;
1162				case HostPortal: return "Portal";
1163				case HostRoot: return "Root";
1164				case HostText: return "Text";
1165				case LazyComponent: return getComponentNameFromType(type);
1166				case Mode:
1167					if (type === REACT_STRICT_MODE_TYPE) return "StrictMode";
1168					return "Mode";
1169				case OffscreenComponent: return "Offscreen";
1170				case Profiler: return "Profiler";
1171				case ScopeComponent: return "Scope";
1172				case SuspenseComponent: return "Suspense";
1173				case SuspenseListComponent: return "SuspenseList";
1174				case TracingMarkerComponent: return "TracingMarker";
1175				case ClassComponent:
1176				case FunctionComponent:
1177				case IncompleteClassComponent:
1178				case IndeterminateComponent:
1179				case MemoComponent:
1180				case SimpleMemoComponent:
1181					if (typeof type === "function") return type.displayName || type.name || null;
1182					if (typeof type === "string") return type;
1183					break;
1184			}
1185			return null;
1186		}
1187		var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
1188		var current = null;
1189		var isRendering = false;

1190		function getCurrentFiberOwnerNameInDevOrNull() {
1191			if (current === null) return null;
1192			var owner = current._debugOwner;
1193			if (owner !== null && typeof owner !== "undefined") return getComponentNameFromFiber(owner);
1194			return null;
1195		}
1196		function getCurrentFiberStackInDev() {
1197			if (current === null) return "";
1198			return getStackByFiberInDevAndProd(current);
1199		}
1200		function resetCurrentFiber() {
1201			ReactDebugCurrentFrame.getCurrentStack = null;
1202			current = null;
1203			isRendering = false;
1204		}
1205		function setCurrentFiber(fiber) {
1206			ReactDebugCurrentFrame.getCurrentStack = fiber === null ? null : getCurrentFiberStackInDev;
1207			current = fiber;
1208			isRendering = false;
1209		}
1210		function getCurrentFiber() {
1211			return current;
1212		}
1213		function setIsRendering(rendering) {
1214			isRendering = rendering;
1215		}
1216		function toString(value) {
1217			return "" + value;
1218		}
1219		function getToStringValue(value) {
1220			switch (typeof value) {
1221				case "boolean":
1222				case "number":
1223				case "string":
1224				case "undefined": return value;
1225				case "object":
1226					checkFormFieldValueStringCoercion(value);
1227					return value;
1228				default: return "";
1229			}
1230		}
1231		var hasReadOnlyValue = {
1232			button: true,
1233			checkbox: true,
1234			image: true,
1235			hidden: true,
1236			radio: true,
1237			reset: true,
1238			submit: true
1239		};
1240		function checkControlledValueProps(tagName, props) {
1241			if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`.");
1242			if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`.");
1243		}
1244		function isCheckable(elem) {
1245			var type = elem.type;
1246			var nodeName = elem.nodeName;
1247			return nodeName && nodeName.toLowerCase() === "input" && (type === "checkbox" || type === "radio");
1248		}
1249		function getTracker(node) {
1250			return node._valueTracker;
1251		}
1252		function detachTracker(node) {
1253			node._valueTracker = null;
1254		}
1255		function getValueFromNode(node) {
1256			var value = "";
1257			if (!node) return value;
1258			if (isCheckable(node)) value = node.checked ? "true" : "false";
1259			else value = node.value;
1260			return value;
1261		}
1262		function trackValueOnNode(node) {
1263			var valueField = isCheckable(node) ? "checked" : "value";
1264			var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
1265			checkFormFieldValueStringCoercion(node[valueField]);
1266			var currentValue = "" + node[valueField];
1267			if (node.hasOwnProperty(valueField) || typeof descriptor === "undefined" || typeof descriptor.get !== "function" || typeof descriptor.set !== "function") return;
1268			var get$1 = descriptor.get, set$1 = descriptor.set;
1269			Object.defineProperty(node, valueField, {
1270				configurable: true,
1271				get: function() {
1272					return get$1.call(this);
1273				},
1274				set: function(value) {
1275					checkFormFieldValueStringCoercion(value);
1276					currentValue = "" + value;
1277					set$1.call(this, value);
1278				}
1279			});
1280			Object.defineProperty(node, valueField, { enumerable: descriptor.enumerable });
1281			return {
1282				getValue: function() {
1283					return currentValue;
1284				},
1285				setValue: function(value) {
1286					checkFormFieldValueStringCoercion(value);
1287					currentValue = "" + value;
1288				},
1289				stopTracking: function() {
1290					detachTracker(node);
1291					delete node[valueField];
1292				}
1293			};
1294		}
1295		function track(node) {
1296			if (getTracker(node)) return;
1297			node._valueTracker = trackValueOnNode(node);
1298		}
1299		function updateValueIfChanged(node) {
1300			if (!node) return false;
1301			var tracker = getTracker(node);
1302			if (!tracker) return true;
1303			var lastValue = tracker.getValue();
1304			var nextValue = getValueFromNode(node);
1305			if (nextValue !== lastValue) {
1306				tracker.setValue(nextValue);
1307				return true;
1308			}
1309			return false;

1310		}
1311		function getActiveElement(doc) {
1312			doc = doc || (typeof document !== "undefined" ? document : void 0);
1313			if (typeof doc === "undefined") return null;
1314			try {
1315				return doc.activeElement || doc.body;
1316			} catch (e) {
1317				return doc.body;
1318			}
1319		}
1320		var didWarnValueDefaultValue = false;
1321		var didWarnCheckedDefaultChecked = false;
1322		var didWarnControlledToUncontrolled = false;
1323		var didWarnUncontrolledToControlled = false;
1324		function isControlled(props) {
1325			return props.type === "checkbox" || props.type === "radio" ? props.checked != null : props.value != null;
1326		}
1327		function getHostProps(element, props) {
1328			var node = element;
1329			var checked = props.checked;
1330			return assign({}, props, {
1331				defaultChecked: void 0,
1332				defaultValue: void 0,
1333				value: void 0,
1334				checked: checked != null ? checked : node._wrapperState.initialChecked
1335			});
1336		}
1337		function initWrapperState(element, props) {
1338			checkControlledValueProps("input", props);
1339			if (props.checked !== void 0 && props.defaultChecked !== void 0 && !didWarnCheckedDefaultChecked) {
1340				error("%s contains an input of type %s with both checked and defaultChecked props. Input elements must be either controlled or uncontrolled (specify either the checked prop, or the defaultChecked prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type);
1341				didWarnCheckedDefaultChecked = true;
1342			}
1343			if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnValueDefaultValue) {
1344				error("%s contains an input of type %s with both value and defaultValue props. Input elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type);
1345				didWarnValueDefaultValue = true;
1346			}
1347			var node = element;
1348			var defaultValue = props.defaultValue == null ? "" : props.defaultValue;
1349			node._wrapperState = {
1350				initialChecked: props.checked != null ? props.checked : props.defaultChecked,
1351				initialValue: getToStringValue(props.value != null ? props.value : defaultValue),
1352				controlled: isControlled(props)
1353			};
1354		}
1355		function updateChecked(element, props) {
1356			var node = element;
1357			var checked = props.checked;
1358			if (checked != null) setValueForProperty(node, "checked", checked, false);
1359		}
1360		function updateWrapper(element, props) {
1361			var node = element;
1362			var controlled = isControlled(props);
1363			if (!node._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) {
1364				error("A component is changing an uncontrolled input to be controlled. This is likely caused by the value changing from undefined to a defined value, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components");
1365				didWarnUncontrolledToControlled = true;
1366			}
1367			if (node._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) {
1368				error("A component is changing a controlled input to be uncontrolled. This is likely caused by the value changing from a defined to undefined, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components");
1369				didWarnControlledToUncontrolled = true;
1370			}
1371			updateChecked(element, props);
1372			var value = getToStringValue(props.value);
1373			var type = props.type;
1374			if (value != null) {
1375				if (type === "number") {
1376					if (value === 0 && node.value === "" || node.value != value) node.value = toString(value);
1377				} else if (node.value !== toString(value)) node.value = toString(value);
1378			} else if (type === "submit" || type === "reset") {
1379				node.removeAttribute("value");
1380				return;
1381			}
1382			if (props.hasOwnProperty("value")) setDefaultValue(node, props.type, value);
1383			else if (props.hasOwnProperty("defaultValue")) setDefaultValue(node, props.type, getToStringValue(props.defaultValue));
1384			if (props.checked == null && props.defaultChecked != null) node.defaultChecked = !!props.defaultChecked;
1385		}
1386		function postMountWrapper(element, props, isHydrating$1) {
1387			var node = element;
1388			if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) {
1389				var type = props.type;
1390				if ((type === "submit" || type === "reset") && (props.value === void 0 || props.value === null)) return;
1391				var initialValue = toString(node._wrapperState.initialValue);
1392				if (!isHydrating$1) {
1393					if (initialValue !== node.value) node.value = initialValue;
1394				}
1395				node.defaultValue = initialValue;
1396			}
1397			var name = node.name;
1398			if (name !== "") node.name = "";
1399			node.defaultChecked = !node.defaultChecked;
1400			node.defaultChecked = !!node._wrapperState.initialChecked;
1401			if (name !== "") node.name = name;
1402		}
1403		function restoreControlledState(element, props) {
1404			var node = element;
1405			updateWrapper(node, props);
1406			updateNamedCousins(node, props);
1407		}
1408		function updateNamedCousins(rootNode, props) {
1409			var name = props.name;
1410			if (props.type === "radio" && name != null) {
1411				var queryRoot = rootNode;
1412				while (queryRoot.parentNode) queryRoot = queryRoot.parentNode;
1413				checkAttributeStringCoercion(name, "name");
1414				var group = queryRoot.querySelectorAll("input[name=" + JSON.stringify("" + name) + "][type=\"radio\"]");
1415				for (var i = 0; i < group.length; i++) {
1416					var otherNode = group[i];

1417					if (otherNode === rootNode || otherNode.form !== rootNode.form) continue;
1418					var otherProps = getFiberCurrentPropsFromNode(otherNode);
1419					if (!otherProps) throw new Error("ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.");
1420					updateValueIfChanged(otherNode);
1421					updateWrapper(otherNode, otherProps);
1422				}
1423			}
1424		}
1425		function setDefaultValue(node, type, value) {
1426			if (type !== "number" || getActiveElement(node.ownerDocument) !== node) {
1427				if (value == null) node.defaultValue = toString(node._wrapperState.initialValue);
1428				else if (node.defaultValue !== toString(value)) node.defaultValue = toString(value);
1429			}
1430		}
1431		var didWarnSelectedSetOnOption = false;
1432		var didWarnInvalidChild = false;
1433		var didWarnInvalidInnerHTML = false;
1434		function validateProps(element, props) {
1435			if (props.value == null) {
1436				if (typeof props.children === "object" && props.children !== null) React.Children.forEach(props.children, function(child) {
1437					if (child == null) return;
1438					if (typeof child === "string" || typeof child === "number") return;
1439					if (!didWarnInvalidChild) {
1440						didWarnInvalidChild = true;
1441						error("Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to <option>.");
1442					}
1443				});
1444				else if (props.dangerouslySetInnerHTML != null) {
1445					if (!didWarnInvalidInnerHTML) {
1446						didWarnInvalidInnerHTML = true;
1447						error("Pass a `value` prop if you set dangerouslyInnerHTML so React knows which value should be selected.");
1448					}
1449				}
1450			}
1451			if (props.selected != null && !didWarnSelectedSetOnOption) {
1452				error("Use the `defaultValue` or `value` props on <select> instead of setting `selected` on <option>.");
1453				didWarnSelectedSetOnOption = true;
1454			}
1455		}
1456		function postMountWrapper$1(element, props) {
1457			if (props.value != null) element.setAttribute("value", toString(getToStringValue(props.value)));
1458		}
1459		var isArrayImpl = Array.isArray;
1460		function isArray(a) {
1461			return isArrayImpl(a);
1462		}
1463		var didWarnValueDefaultValue$1 = false;
1464		function getDeclarationErrorAddendum() {
1465			var ownerName = getCurrentFiberOwnerNameInDevOrNull();
1466			if (ownerName) return "\n\nCheck the render method of `" + ownerName + "`.";
1467			return "";
1468		}
1469		var valuePropNames = ["value", "defaultValue"];
1470		function checkSelectPropTypes(props) {
1471			checkControlledValueProps("select", props);
1472			for (var i = 0; i < valuePropNames.length; i++) {
1473				var propName = valuePropNames[i];
1474				if (props[propName] == null) continue;
1475				var propNameIsArray = isArray(props[propName]);
1476				if (props.multiple && !propNameIsArray) error("The `%s` prop supplied to <select> must be an array if `multiple` is true.%s", propName, getDeclarationErrorAddendum());
1477				else if (!props.multiple && propNameIsArray) error("The `%s` prop supplied to <select> must be a scalar value if `multiple` is false.%s", propName, getDeclarationErrorAddendum());
1478			}
1479		}
1480		function updateOptions(node, multiple, propValue, setDefaultSelected) {
1481			var options$1 = node.options;
1482			if (multiple) {
1483				var selectedValues = propValue;
1484				var selectedValue = {};
1485				for (var i = 0; i < selectedValues.length; i++) selectedValue["$" + selectedValues[i]] = true;
1486				for (var _i = 0; _i < options$1.length; _i++) {
1487					var selected = selectedValue.hasOwnProperty("$" + options$1[_i].value);
1488					if (options$1[_i].selected !== selected) options$1[_i].selected = selected;
1489					if (selected && setDefaultSelected) options$1[_i].defaultSelected = true;
1490				}
1491			} else {
1492				var _selectedValue = toString(getToStringValue(propValue));
1493				var defaultSelected = null;
1494				for (var _i2 = 0; _i2 < options$1.length; _i2++) {
1495					if (options$1[_i2].value === _selectedValue) {
1496						options$1[_i2].selected = true;
1497						if (setDefaultSelected) options$1[_i2].defaultSelected = true;
1498						return;
1499					}
1500					if (defaultSelected === null && !options$1[_i2].disabled) defaultSelected = options$1[_i2];
1501				}
1502				if (defaultSelected !== null) defaultSelected.selected = true;
1503			}
1504		}
1505		function getHostProps$1(element, props) {
1506			return assign({}, props, { value: void 0 });
1507		}
1508		function initWrapperState$1(element, props) {
1509			var node = element;
1510			checkSelectPropTypes(props);
1511			node._wrapperState = { wasMultiple: !!props.multiple };
1512			if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnValueDefaultValue$1) {
1513				error("Select elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled select element and remove one of these props. More info: https://reactjs.org/link/controlled-components");
1514				didWarnValueDefaultValue$1 = true;
1515			}
1516		}
1517		function postMountWrapper$2(element, props) {
1518			var node = element;
1519			node.multiple = !!props.multiple;
1520			var value = props.value;
1521			if (value != null) updateOptions(node, !!props.multiple, value, false);
1522			else if (props.defaultValue != null) updateOptions(node, !!props.multiple, props.defaultValue, true);
1523		}
1524		function postUpdateWrapper(element, props) {
1525			var node = element;
1526			var wasMultiple = node._wrapperState.wasMultiple;
1527			node._wrapperState.wasMultiple = !!props.multiple;
1528			var value = props.value;
1529			if (value != null) updateOptions(node, !!props.multiple, value, false);
1530			else if (wasMultiple !== !!props.multiple) if (props.defaultValue != null) updateOptions(node, !!props.multiple, props.defaultValue, true);
1531			else updateOptions(node, !!props.multiple, props.multiple ? [] : "", false);
1532		}
1533		function restoreControlledState$1(element, props) {
1534			var node = element;
1535			var value = props.value;
1536			if (value != null) updateOptions(node, !!props.multiple, value, false);
1537		}
1538		var didWarnValDefaultVal = false;

1539		function getHostProps$2(element, props) {
1540			var node = element;
1541			if (props.dangerouslySetInnerHTML != null) throw new Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");
1542			return assign({}, props, {
1543				value: void 0,
1544				defaultValue: void 0,
1545				children: toString(node._wrapperState.initialValue)
1546			});
1547		}
1548		function initWrapperState$2(element, props) {
1549			var node = element;
1550			checkControlledValueProps("textarea", props);
1551			if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnValDefaultVal) {
1552				error("%s contains a textarea with both value and defaultValue props. Textarea elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled textarea and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component");
1553				didWarnValDefaultVal = true;
1554			}
1555			var initialValue = props.value;
1556			if (initialValue == null) {
1557				var children = props.children, defaultValue = props.defaultValue;
1558				if (children != null) {
1559					error("Use the `defaultValue` or `value` props instead of setting children on <textarea>.");
1560					if (defaultValue != null) throw new Error("If you supply `defaultValue` on a <textarea>, do not pass children.");
1561					if (isArray(children)) {
1562						if (children.length > 1) throw new Error("<textarea> can only have at most one child.");
1563						children = children[0];
1564					}
1565					defaultValue = children;
1566				}
1567				if (defaultValue == null) defaultValue = "";
1568				initialValue = defaultValue;
1569			}
1570			node._wrapperState = { initialValue: getToStringValue(initialValue) };
1571		}
1572		function updateWrapper$1(element, props) {
1573			var node = element;
1574			var value = getToStringValue(props.value);
1575			var defaultValue = getToStringValue(props.defaultValue);
1576			if (value != null) {
1577				var newValue = toString(value);
1578				if (newValue !== node.value) node.value = newValue;
1579				if (props.defaultValue == null && node.defaultValue !== newValue) node.defaultValue = newValue;
1580			}
1581			if (defaultValue != null) node.defaultValue = toString(defaultValue);
1582		}
1583		function postMountWrapper$3(element, props) {
1584			var node = element;
1585			var textContent = node.textContent;
1586			if (textContent === node._wrapperState.initialValue) {
1587				if (textContent !== "" && textContent !== null) node.value = textContent;
1588			}
1589		}
1590		function restoreControlledState$2(element, props) {
1591			updateWrapper$1(element, props);
1592		}
1593		var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
1594		var MATH_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
1595		var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
1596		function getIntrinsicNamespace(type) {
1597			switch (type) {
1598				case "svg": return SVG_NAMESPACE;
1599				case "math": return MATH_NAMESPACE;
1600				default: return HTML_NAMESPACE;
1601			}
1602		}
1603		function getChildNamespace(parentNamespace, type) {
1604			if (parentNamespace == null || parentNamespace === HTML_NAMESPACE) return getIntrinsicNamespace(type);
1605			if (parentNamespace === SVG_NAMESPACE && type === "foreignObject") return HTML_NAMESPACE;
1606			return parentNamespace;
1607		}
1608		var createMicrosoftUnsafeLocalFunction = function(func) {
1609			if (typeof MSApp !== "undefined" && MSApp.execUnsafeLocalFunction) return function(arg0, arg1, arg2, arg3) {
1610				MSApp.execUnsafeLocalFunction(function() {
1611					return func(arg0, arg1, arg2, arg3);
1612				});
1613			};
1614			else return func;
1615		};
1616		var reusableSVGContainer;
1617		var setInnerHTML = createMicrosoftUnsafeLocalFunction(function(node, html) {
1618			if (node.namespaceURI === SVG_NAMESPACE) {
1619				if (!("innerHTML" in node)) {
1620					reusableSVGContainer = reusableSVGContainer || document.createElement("div");
1621					reusableSVGContainer.innerHTML = "<svg>" + html.valueOf().toString() + "</svg>";
1622					var svgNode = reusableSVGContainer.firstChild;
1623					while (node.firstChild) node.removeChild(node.firstChild);
1624					while (svgNode.firstChild) node.appendChild(svgNode.firstChild);
1625					return;
1626				}
1627			}
1628			node.innerHTML = html;
1629		});
1630		var ELEMENT_NODE = 1;
1631		var TEXT_NODE = 3;
1632		var COMMENT_NODE = 8;
1633		var DOCUMENT_NODE = 9;
1634		var DOCUMENT_FRAGMENT_NODE = 11;
1635		var setTextContent = function(node, text) {
1636			if (text) {
1637				var firstChild = node.firstChild;

1638				if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
1639					firstChild.nodeValue = text;
1640					return;
1641				}
1642			}
1643			node.textContent = text;
1644		};
1645		var shorthandToLonghand = {
1646			animation: [
1647				"animationDelay",
1648				"animationDirection",
1649				"animationDuration",
1650				"animationFillMode",
1651				"animationIterationCount",
1652				"animationName",
1653				"animationPlayState",
1654				"animationTimingFunction"
1655			],
1656			background: [
1657				"backgroundAttachment",
1658				"backgroundClip",
1659				"backgroundColor",
1660				"backgroundImage",
1661				"backgroundOrigin",
1662				"backgroundPositionX",
1663				"backgroundPositionY",
1664				"backgroundRepeat",
1665				"backgroundSize"
1666			],
1667			backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
1668			border: [
1669				"borderBottomColor",
1670				"borderBottomStyle",
1671				"borderBottomWidth",
1672				"borderImageOutset",
1673				"borderImageRepeat",
1674				"borderImageSlice",
1675				"borderImageSource",
1676				"borderImageWidth",
1677				"borderLeftColor",
1678				"borderLeftStyle",
1679				"borderLeftWidth",
1680				"borderRightColor",
1681				"borderRightStyle",
1682				"borderRightWidth",
1683				"borderTopColor",
1684				"borderTopStyle",
1685				"borderTopWidth"
1686			],
1687			borderBlockEnd: [
1688				"borderBlockEndColor",
1689				"borderBlockEndStyle",
1690				"borderBlockEndWidth"
1691			],
1692			borderBlockStart: [
1693				"borderBlockStartColor",
1694				"borderBlockStartStyle",
1695				"borderBlockStartWidth"
1696			],
1697			borderBottom: [
1698				"borderBottomColor",
1699				"borderBottomStyle",
1700				"borderBottomWidth"
1701			],
1702			borderColor: [
1703				"borderBottomColor",
1704				"borderLeftColor",
1705				"borderRightColor",
1706				"borderTopColor"
1707			],
1708			borderImage: [
1709				"borderImageOutset",
1710				"borderImageRepeat",
1711				"borderImageSlice",
1712				"borderImageSource",
1713				"borderImageWidth"
1714			],
1715			borderInlineEnd: [
1716				"borderInlineEndColor",
1717				"borderInlineEndStyle",
1718				"borderInlineEndWidth"
1719			],
1720			borderInlineStart: [
1721				"borderInlineStartColor",
1722				"borderInlineStartStyle",
1723				"borderInlineStartWidth"
1724			],
1725			borderLeft: [
1726				"borderLeftColor",
1727				"borderLeftStyle",
1728				"borderLeftWidth"
1729			],
1730			borderRadius: [
1731				"borderBottomLeftRadius",
1732				"borderBottomRightRadius",
1733				"borderTopLeftRadius",
1734				"borderTopRightRadius"
1735			],
1736			borderRight: [
1737				"borderRightColor",
1738				"borderRightStyle",
1739				"borderRightWidth"
1740			],
1741			borderStyle: [
1742				"borderBottomStyle",
1743				"borderLeftStyle",
1744				"borderRightStyle",
1745				"borderTopStyle"
1746			],
1747			borderTop: [
1748				"borderTopColor",
1749				"borderTopStyle",
1750				"borderTopWidth"
1751			],
1752			borderWidth: [
1753				"borderBottomWidth",
1754				"borderLeftWidth",
1755				"borderRightWidth",
1756				"borderTopWidth"
1757			],
1758			columnRule: [
1759				"columnRuleColor",
1760				"columnRuleStyle",
1761				"columnRuleWidth"
1762			],
1763			columns: ["columnCount", "columnWidth"],
1764			flex: [
1765				"flexBasis",
1766				"flexGrow",
1767				"flexShrink"
1768			],
1769			flexFlow: ["flexDirection", "flexWrap"],
1770			font: [
1771				"fontFamily",
1772				"fontFeatureSettings",
1773				"fontKerning",
1774				"fontLanguageOverride",
1775				"fontSize",
1776				"fontSizeAdjust",
1777				"fontStretch",
1778				"fontStyle",
1779				"fontVariant",
1780				"fontVariantAlternates",
1781				"fontVariantCaps",
1782				"fontVariantEastAsian",
1783				"fontVariantLigatures",
1784				"fontVariantNumeric",
1785				"fontVariantPosition",
1786				"fontWeight",
1787				"lineHeight"
1788			],
1789			fontVariant: [
1790				"fontVariantAlternates",
1791				"fontVariantCaps",
1792				"fontVariantEastAsian",
1793				"fontVariantLigatures",
1794				"fontVariantNumeric",
1795				"fontVariantPosition"
1796			],
1797			gap: ["columnGap", "rowGap"],
1798			grid: [
1799				"gridAutoColumns",
1800				"gridAutoFlow",
1801				"gridAutoRows",
1802				"gridTemplateAreas",
1803				"gridTemplateColumns",
1804				"gridTemplateRows"
1805			],
1806			gridArea: [
1807				"gridColumnEnd",
1808				"gridColumnStart",
1809				"gridRowEnd",
1810				"gridRowStart"
1811			],
1812			gridColumn: ["gridColumnEnd", "gridColumnStart"],
1813			gridColumnGap: ["columnGap"],
1814			gridGap: ["columnGap", "rowGap"],
1815			gridRow: ["gridRowEnd", "gridRowStart"],
1816			gridRowGap: ["rowGap"],
1817			gridTemplate: [
1818				"gridTemplateAreas",
1819				"gridTemplateColumns",
1820				"gridTemplateRows"
1821			],
1822			listStyle: [
1823				"listStyleImage",
1824				"listStylePosition",
1825				"listStyleType"
1826			],
1827			margin: [
1828				"marginBottom",
1829				"marginLeft",
1830				"marginRight",
1831				"marginTop"
1832			],
1833			marker: [
1834				"markerEnd",
1835				"markerMid",
1836				"markerStart"
1837			],
1838			mask: [
1839				"maskClip",
1840				"maskComposite",
1841				"maskImage",
1842				"maskMode",
1843				"maskOrigin",
1844				"maskPositionX",
1845				"maskPositionY",
1846				"maskRepeat",
1847				"maskSize"
1848			],
1849			maskPosition: ["maskPositionX", "maskPositionY"],
1850			outline: [
1851				"outlineColor",
1852				"outlineStyle",
1853				"outlineWidth"
1854			],
1855			overflow: ["overflowX", "overflowY"],
1856			padding: [
1857				"paddingBottom",
1858				"paddingLeft",
1859				"paddingRight",
1860				"paddingTop"
1861			],
1862			placeContent: ["alignContent", "justifyContent"],
1863			placeItems: ["alignItems", "justifyItems"],
1864			placeSelf: ["alignSelf", "justifySelf"],
1865			textDecoration: [
1866				"textDecorationColor",
1867				"textDecorationLine",
1868				"textDecorationStyle"
1869			],
1870			textEmphasis: ["textEmphasisColor", "textEmphasisStyle"],
1871			transition: [
1872				"transitionDelay",
1873				"transitionDuration",
1874				"transitionProperty",
1875				"transitionTimingFunction"
1876			],
1877			wordWrap: ["overflowWrap"]
1878		};
1879		var isUnitlessNumber = {
1880			animationIterationCount: true,
1881			aspectRatio: true,
1882			borderImageOutset: true,
1883			borderImageSlice: true,
1884			borderImageWidth: true,
1885			boxFlex: true,
1886			boxFlexGroup: true,
1887			boxOrdinalGroup: true,
1888			columnCount: true,
1889			columns: true,
1890			flex: true,
1891			flexGrow: true,
1892			flexPositive: true,
1893			flexShrink: true,
1894			flexNegative: true,
1895			flexOrder: true,
1896			gridArea: true,
1897			gridRow: true,
1898			gridRowEnd: true,
1899			gridRowSpan: true,
1900			gridRowStart: true,
1901			gridColumn: true,
1902			gridColumnEnd: true,
1903			gridColumnSpan: true,
1904			gridColumnStart: true,
1905			fontWeight: true,
1906			lineClamp: true,
1907			lineHeight: true,
1908			opacity: true,
1909			order: true,
1910			orphans: true,
1911			tabSize: true,
1912			widows: true,
1913			zIndex: true,
1914			zoom: true,
1915			fillOpacity: true,
1916			floodOpacity: true,
1917			stopOpacity: true,
1918			strokeDasharray: true,
1919			strokeDashoffset: true,
1920			strokeMiterlimit: true,
1921			strokeOpacity: true,
1922			strokeWidth: true
1923		};
1924		function prefixKey(prefix$1, key) {
1925			return prefix$1 + key.charAt(0).toUpperCase() + key.substring(1);
1926		}
1927		var prefixes = [
1928			"Webkit",
1929			"ms",
1930			"Moz",
1931			"O"
1932		];
1933		Object.keys(isUnitlessNumber).forEach(function(prop) {

1934			prefixes.forEach(function(prefix$1) {
1935				isUnitlessNumber[prefixKey(prefix$1, prop)] = isUnitlessNumber[prop];
1936			});
1937		});
1938		function dangerousStyleValue(name, value, isCustomProperty) {
1939			if (value == null || typeof value === "boolean" || value === "") return "";
1940			if (!isCustomProperty && typeof value === "number" && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + "px";
1941			checkCSSPropertyStringCoercion(value, name);
1942			return ("" + value).trim();
1943		}
1944		var uppercasePattern = /([A-Z])/g;
1945		var msPattern = /^ms-/;
1946		function hyphenateStyleName(name) {
1947			return name.replace(uppercasePattern, "-$1").toLowerCase().replace(msPattern, "-ms-");
1948		}
1949		var warnValidStyle = function() {};
1950		var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
1951		var msPattern$1 = /^-ms-/;
1952		var hyphenPattern = /-(.)/g;
1953		var badStyleValueWithSemicolonPattern = /;\s*$/;
1954		var warnedStyleNames = {};
1955		var warnedStyleValues = {};
1956		var warnedForNaNValue = false;
1957		var warnedForInfinityValue = false;
1958		var camelize = function(string) {
1959			return string.replace(hyphenPattern, function(_, character) {
1960				return character.toUpperCase();
1961			});
1962		};
1963		var warnHyphenatedStyleName = function(name) {
1964			if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) return;
1965			warnedStyleNames[name] = true;
1966			error("Unsupported style property %s. Did you mean %s?", name, camelize(name.replace(msPattern$1, "ms-")));
1967		};
1968		var warnBadVendoredStyleName = function(name) {
1969			if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) return;
1970			warnedStyleNames[name] = true;
1971			error("Unsupported vendor-prefixed style property %s. Did you mean %s?", name, name.charAt(0).toUpperCase() + name.slice(1));
1972		};
1973		var warnStyleValueWithSemicolon = function(name, value) {
1974			if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) return;
1975			warnedStyleValues[value] = true;
1976			error("Style property values shouldn't contain a semicolon. Try \"%s: %s\" instead.", name, value.replace(badStyleValueWithSemicolonPattern, ""));
1977		};
1978		var warnStyleValueIsNaN = function(name, value) {
1979			if (warnedForNaNValue) return;
1980			warnedForNaNValue = true;
1981			error("`NaN` is an invalid value for the `%s` css style property.", name);
1982		};
1983		var warnStyleValueIsInfinity = function(name, value) {
1984			if (warnedForInfinityValue) return;
1985			warnedForInfinityValue = true;
1986			error("`Infinity` is an invalid value for the `%s` css style property.", name);
1987		};
1988		warnValidStyle = function(name, value) {
1989			if (name.indexOf("-") > -1) warnHyphenatedStyleName(name);
1990			else if (badVendoredStyleNamePattern.test(name)) warnBadVendoredStyleName(name);
1991			else if (badStyleValueWithSemicolonPattern.test(value)) warnStyleValueWithSemicolon(name, value);
1992			if (typeof value === "number") {
1993				if (isNaN(value)) warnStyleValueIsNaN(name, value);
1994				else if (!isFinite(value)) warnStyleValueIsInfinity(name, value);
1995			}
1996		};
1997		var warnValidStyle$1 = warnValidStyle;
1998		function createDangerousStringForStyles(styles) {
1999			var serialized = "";
2000			var delimiter = "";
2001			for (var styleName in styles) {
2002				if (!styles.hasOwnProperty(styleName)) continue;
2003				var styleValue = styles[styleName];
2004				if (styleValue != null) {
2005					var isCustomProperty = styleName.indexOf("--") === 0;
2006					serialized += delimiter + (isCustomProperty ? styleName : hyphenateStyleName(styleName)) + ":";
2007					serialized += dangerousStyleValue(styleName, styleValue, isCustomProperty);
2008					delimiter = ";";
2009				}
2010			}
2011			return serialized || null;
2012		}
2013		function setValueForStyles(node, styles) {
2014			var style$1 = node.style;
2015			for (var styleName in styles) {
2016				if (!styles.hasOwnProperty(styleName)) continue;
2017				var isCustomProperty = styleName.indexOf("--") === 0;
2018				if (!isCustomProperty) warnValidStyle$1(styleName, styles[styleName]);
2019				var styleValue = dangerousStyleValue(styleName, styles[styleName], isCustomProperty);
2020				if (styleName === "float") styleName = "cssFloat";
2021				if (isCustomProperty) style$1.setProperty(styleName, styleValue);
2022				else style$1[styleName] = styleValue;
2023			}
2024		}
2025		function isValueEmpty(value) {
2026			return value == null || typeof value === "boolean" || value === "";
2027		}
2028		function expandShorthandMap(styles) {
2029			var expanded = {};
2030			for (var key in styles) {
2031				var longhands = shorthandToLonghand[key] || [key];
2032				for (var i = 0; i < longhands.length; i++) expanded[longhands[i]] = key;
2033			}
2034			return expanded;
2035		}
2036		function validateShorthandPropertyCollisionInDev(styleUpdates, nextStyles) {
2037			if (!nextStyles) return;

2038			var expandedUpdates = expandShorthandMap(styleUpdates);
2039			var expandedStyles = expandShorthandMap(nextStyles);
2040			var warnedAbout = {};
2041			for (var key in expandedUpdates) {
2042				var originalKey = expandedUpdates[key];
2043				var correctOriginalKey = expandedStyles[key];
2044				if (correctOriginalKey && originalKey !== correctOriginalKey) {
2045					var warningKey = originalKey + "," + correctOriginalKey;
2046					if (warnedAbout[warningKey]) continue;
2047					warnedAbout[warningKey] = true;
2048					error("%s a style property during rerender (%s) when a conflicting property is set (%s) can lead to styling bugs. To avoid this, don't mix shorthand and non-shorthand properties for the same value; instead, replace the shorthand with separate values.", isValueEmpty(styleUpdates[originalKey]) ? "Removing" : "Updating", originalKey, correctOriginalKey);
2049				}
2050			}
2051		}
2052		var voidElementTags = assign({ menuitem: true }, {
2053			area: true,
2054			base: true,
2055			br: true,
2056			col: true,
2057			embed: true,
2058			hr: true,
2059			img: true,
2060			input: true,
2061			keygen: true,
2062			link: true,
2063			meta: true,
2064			param: true,
2065			source: true,
2066			track: true,
2067			wbr: true
2068		});
2069		var HTML = "__html";
2070		function assertValidProps(tag, props) {
2071			if (!props) return;
2072			if (voidElementTags[tag]) {
2073				if (props.children != null || props.dangerouslySetInnerHTML != null) throw new Error(tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
2074			}
2075			if (props.dangerouslySetInnerHTML != null) {
2076				if (props.children != null) throw new Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
2077				if (typeof props.dangerouslySetInnerHTML !== "object" || !(HTML in props.dangerouslySetInnerHTML)) throw new Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");
2078			}
2079			if (!props.suppressContentEditableWarning && props.contentEditable && props.children != null) error("A component is `contentEditable` and contains `children` managed by React. It is now your responsibility to guarantee that none of those nodes are unexpectedly modified or duplicated. This is probably not intentional.");
2080			if (props.style != null && typeof props.style !== "object") throw new Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");
2081		}
2082		function isCustomComponent(tagName, props) {
2083			if (tagName.indexOf("-") === -1) return typeof props.is === "string";
2084			switch (tagName) {
2085				case "annotation-xml":
2086				case "color-profile":
2087				case "font-face":
2088				case "font-face-src":
2089				case "font-face-uri":
2090				case "font-face-format":
2091				case "font-face-name":
2092				case "missing-glyph": return false;
2093				default: return true;
2094			}
2095		}
2096		var possibleStandardNames = {
2097			accept: "accept",
2098			acceptcharset: "acceptCharset",
2099			"accept-charset": "acceptCharset",
2100			accesskey: "accessKey",
2101			action: "action",
2102			allowfullscreen: "allowFullScreen",
2103			alt: "alt",
2104			as: "as",
2105			async: "async",
2106			autocapitalize: "autoCapitalize",
2107			autocomplete: "autoComplete",
2108			autocorrect: "autoCorrect",
2109			autofocus: "autoFocus",
2110			autoplay: "autoPlay",
2111			autosave: "autoSave",
2112			capture: "capture",
2113			cellpadding: "cellPadding",
2114			cellspacing: "cellSpacing",
2115			challenge: "challenge",
2116			charset: "charSet",
2117			checked: "checked",
2118			children: "children",
2119			cite: "cite",
2120			class: "className",
2121			classid: "classID",
2122			classname: "className",
2123			cols: "cols",
2124			colspan: "colSpan",
2125			content: "content",
2126			contenteditable: "contentEditable",
2127			contextmenu: "contextMenu",
2128			controls: "controls",
2129			controlslist: "controlsList",
2130			coords: "coords",
2131			crossorigin: "crossOrigin",
2132			dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
2133			data: "data",
2134			datetime: "dateTime",
2135			default: "default",
2136			defaultchecked: "defaultChecked",
2137			defaultvalue: "defaultValue",
2138			defer: "defer",
2139			dir: "dir",
2140			disabled: "disabled",
2141			disablepictureinpicture: "disablePictureInPicture",
2142			disableremoteplayback: "disableRemotePlayback",
2143			download: "download",
2144			draggable: "draggable",
2145			enctype: "encType",
2146			enterkeyhint: "enterKeyHint",
2147			for: "htmlFor",
2148			form: "form",
2149			formmethod: "formMethod",
2150			formaction: "formAction",
2151			formenctype: "formEncType",
2152			formnovalidate: "formNoValidate",
2153			formtarget: "formTarget",
2154			frameborder: "frameBorder",
2155			headers: "headers",
2156			height: "height",
2157			hidden: "hidden",
2158			high: "high",
2159			href: "href",
2160			hreflang: "hrefLang",
2161			htmlfor: "htmlFor",
2162			httpequiv: "httpEquiv",
2163			"http-equiv": "httpEquiv",
2164			icon: "icon",
2165			id: "id",
2166			imagesizes: "imageSizes",
2167			imagesrcset: "imageSrcSet",

2168			innerhtml: "innerHTML",
2169			inputmode: "inputMode",
2170			integrity: "integrity",
2171			is: "is",
2172			itemid: "itemID",
2173			itemprop: "itemProp",
2174			itemref: "itemRef",
2175			itemscope: "itemScope",
2176			itemtype: "itemType",
2177			keyparams: "keyParams",
2178			keytype: "keyType",
2179			kind: "kind",
2180			label: "label",
2181			lang: "lang",
2182			list: "list",
2183			loop: "loop",
2184			low: "low",
2185			manifest: "manifest",
2186			marginwidth: "marginWidth",
2187			marginheight: "marginHeight",
2188			max: "max",
2189			maxlength: "maxLength",
2190			media: "media",
2191			mediagroup: "mediaGroup",
2192			method: "method",
2193			min: "min",
2194			minlength: "minLength",
2195			multiple: "multiple",
2196			muted: "muted",
2197			name: "name",
2198			nomodule: "noModule",
2199			nonce: "nonce",
2200			novalidate: "noValidate",
2201			open: "open",
2202			optimum: "optimum",
2203			pattern: "pattern",
2204			placeholder: "placeholder",
2205			playsinline: "playsInline",
2206			poster: "poster",
2207			preload: "preload",
2208			profile: "profile",
2209			radiogroup: "radioGroup",
2210			readonly: "readOnly",
2211			referrerpolicy: "referrerPolicy",
2212			rel: "rel",
2213			required: "required",
2214			reversed: "reversed",
2215			role: "role",
2216			rows: "rows",
2217			rowspan: "rowSpan",
2218			sandbox: "sandbox",
2219			scope: "scope",
2220			scoped: "scoped",
2221			scrolling: "scrolling",
2222			seamless: "seamless",
2223			selected: "selected",
2224			shape: "shape",
2225			size: "size",
2226			sizes: "sizes",
2227			span: "span",
2228			spellcheck: "spellCheck",
2229			src: "src",
2230			srcdoc: "srcDoc",
2231			srclang: "srcLang",
2232			srcset: "srcSet",
2233			start: "start",
2234			step: "step",
2235			style: "style",
2236			summary: "summary",
2237			tabindex: "tabIndex",
2238			target: "target",
2239			title: "title",
2240			type: "type",
2241			usemap: "useMap",
2242			value: "value",
2243			width: "width",
2244			wmode: "wmode",
2245			wrap: "wrap",
2246			about: "about",
2247			accentheight: "accentHeight",
2248			"accent-height": "accentHeight",
2249			accumulate: "accumulate",
2250			additive: "additive",
2251			alignmentbaseline: "alignmentBaseline",
2252			"alignment-baseline": "alignmentBaseline",
2253			allowreorder: "allowReorder",
2254			alphabetic: "alphabetic",
2255			amplitude: "amplitude",
2256			arabicform: "arabicForm",
2257			"arabic-form": "arabicForm",
2258			ascent: "ascent",
2259			attributename: "attributeName",
2260			attributetype: "attributeType",
2261			autoreverse: "autoReverse",
2262			azimuth: "azimuth",
2263			basefrequency: "baseFrequency",
2264			baselineshift: "baselineShift",
2265			"baseline-shift": "baselineShift",
2266			baseprofile: "baseProfile",
2267			bbox: "bbox",
2268			begin: "begin",
2269			bias: "bias",
2270			by: "by",
2271			calcmode: "calcMode",
2272			capheight: "capHeight",
2273			"cap-height": "capHeight",
2274			clip: "clip",
2275			clippath: "clipPath",
2276			"clip-path": "clipPath",
2277			clippathunits: "clipPathUnits",
2278			cliprule: "clipRule",
2279			"clip-rule": "clipRule",
2280			color: "color",
2281			colorinterpolation: "colorInterpolation",
2282			"color-interpolation": "colorInterpolation",
2283			colorinterpolationfilters: "colorInterpolationFilters",
2284			"color-interpolation-filters": "colorInterpolationFilters",
2285			colorprofile: "colorProfile",
2286			"color-profile": "colorProfile",
2287			colorrendering: "colorRendering",
2288			"color-rendering": "colorRendering",
2289			contentscripttype: "contentScriptType",
2290			contentstyletype: "contentStyleType",
2291			cursor: "cursor",
2292			cx: "cx",
2293			cy: "cy",
2294			d: "d",
2295			datatype: "datatype",
2296			decelerate: "decelerate",
2297			descent: "descent",
2298			diffuseconstant: "diffuseConstant",
2299			direction: "direction",
2300			display: "display",
2301			divisor: "divisor",
2302			dominantbaseline: "dominantBaseline",
2303			"dominant-baseline": "dominantBaseline",
2304			dur: "dur",
2305			dx: "dx",
2306			dy: "dy",
2307			edgemode: "edgeMode",
2308			elevation: "elevation",
2309			enablebackground: "enableBackground",
2310			"enable-background": "enableBackground",
2311			end: "end",
2312			exponent: "exponent",
2313			externalresourcesrequired: "externalResourcesRequired",
2314			fill: "fill",
2315			fillopacity: "fillOpacity",
2316			"fill-opacity": "fillOpacity",
2317			fillrule: "fillRule",
2318			"fill-rule": "fillRule",
2319			filter: "filter",
2320			filterres: "filterRes",
2321			filterunits: "filterUnits",
2322			floodopacity: "floodOpacity",
2323			"flood-opacity": "floodOpacity",
2324			floodcolor: "floodColor",
2325			"flood-color": "floodColor",
2326			focusable: "focusable",
2327			fontfamily: "fontFamily",
2328			"font-family": "fontFamily",
2329			fontsize: "fontSize",
2330			"font-size": "fontSize",
2331			fontsizeadjust: "fontSizeAdjust",
2332			"font-size-adjust": "fontSizeAdjust",
2333			fontstretch: "fontStretch",
2334			"font-stretch": "fontStretch",
2335			fontstyle: "fontStyle",
2336			"font-style": "fontStyle",
2337			fontvariant: "fontVariant",
2338			"font-variant": "fontVariant",
2339			fontweight: "fontWeight",
2340			"font-weight": "fontWeight",
2341			format: "format",
2342			from: "from",
2343			fx: "fx",
2344			fy: "fy",
2345			g1: "g1",
2346			g2: "g2",
2347			glyphname: "glyphName",
2348			"glyph-name": "glyphName",
2349			glyphorientationhorizontal: "glyphOrientationHorizontal",
2350			"glyph-orientation-horizontal": "glyphOrientationHorizontal",

2351			glyphorientationvertical: "glyphOrientationVertical",
2352			"glyph-orientation-vertical": "glyphOrientationVertical",
2353			glyphref: "glyphRef",
2354			gradienttransform: "gradientTransform",
2355			gradientunits: "gradientUnits",
2356			hanging: "hanging",
2357			horizadvx: "horizAdvX",
2358			"horiz-adv-x": "horizAdvX",
2359			horizoriginx: "horizOriginX",
2360			"horiz-origin-x": "horizOriginX",
2361			ideographic: "ideographic",
2362			imagerendering: "imageRendering",
2363			"image-rendering": "imageRendering",
2364			in2: "in2",
2365			in: "in",
2366			inlist: "inlist",
2367			intercept: "intercept",
2368			k1: "k1",
2369			k2: "k2",
2370			k3: "k3",
2371			k4: "k4",
2372			k: "k",
2373			kernelmatrix: "kernelMatrix",
2374			kernelunitlength: "kernelUnitLength",
2375			kerning: "kerning",
2376			keypoints: "keyPoints",
2377			keysplines: "keySplines",
2378			keytimes: "keyTimes",
2379			lengthadjust: "lengthAdjust",
2380			letterspacing: "letterSpacing",
2381			"letter-spacing": "letterSpacing",
2382			lightingcolor: "lightingColor",
2383			"lighting-color": "lightingColor",
2384			limitingconeangle: "limitingConeAngle",
2385			local: "local",
2386			markerend: "markerEnd",
2387			"marker-end": "markerEnd",
2388			markerheight: "markerHeight",
2389			markermid: "markerMid",
2390			"marker-mid": "markerMid",
2391			markerstart: "markerStart",
2392			"marker-start": "markerStart",
2393			markerunits: "markerUnits",
2394			markerwidth: "markerWidth",
2395			mask: "mask",
2396			maskcontentunits: "maskContentUnits",
2397			maskunits: "maskUnits",
2398			mathematical: "mathematical",
2399			mode: "mode",
2400			numoctaves: "numOctaves",
2401			offset: "offset",
2402			opacity: "opacity",
2403			operator: "operator",
2404			order: "order",
2405			orient: "orient",
2406			orientation: "orientation",
2407			origin: "origin",
2408			overflow: "overflow",
2409			overlineposition: "overlinePosition",
2410			"overline-position": "overlinePosition",
2411			overlinethickness: "overlineThickness",
2412			"overline-thickness": "overlineThickness",
2413			paintorder: "paintOrder",
2414			"paint-order": "paintOrder",
2415			panose1: "panose1",
2416			"panose-1": "panose1",
2417			pathlength: "pathLength",
2418			patterncontentunits: "patternContentUnits",
2419			patterntransform: "patternTransform",
2420			patternunits: "patternUnits",
2421			pointerevents: "pointerEvents",
2422			"pointer-events": "pointerEvents",
2423			points: "points",
2424			pointsatx: "pointsAtX",
2425			pointsaty: "pointsAtY",
2426			pointsatz: "pointsAtZ",
2427			prefix: "prefix",
2428			preservealpha: "preserveAlpha",
2429			preserveaspectratio: "preserveAspectRatio",
2430			primitiveunits: "primitiveUnits",
2431			property: "property",
2432			r: "r",
2433			radius: "radius",
2434			refx: "refX",
2435			refy: "refY",
2436			renderingintent: "renderingIntent",
2437			"rendering-intent": "renderingIntent",
2438			repeatcount: "repeatCount",
2439			repeatdur: "repeatDur",
2440			requiredextensions: "requiredExtensions",
2441			requiredfeatures: "requiredFeatures",
2442			resource: "resource",
2443			restart: "restart",
2444			result: "result",
2445			results: "results",
2446			rotate: "rotate",
2447			rx: "rx",
2448			ry: "ry",
2449			scale: "scale",
2450			security: "security",
2451			seed: "seed",
2452			shaperendering: "shapeRendering",
2453			"shape-rendering": "shapeRendering",
2454			slope: "slope",
2455			spacing: "spacing",
2456			specularconstant: "specularConstant",
2457			specularexponent: "specularExponent",
2458			speed: "speed",
2459			spreadmethod: "spreadMethod",
2460			startoffset: "startOffset",
2461			stddeviation: "stdDeviation",
2462			stemh: "stemh",
2463			stemv: "stemv",
2464			stitchtiles: "stitchTiles",
2465			stopcolor: "stopColor",
2466			"stop-color": "stopColor",
2467			stopopacity: "stopOpacity",
2468			"stop-opacity": "stopOpacity",
2469			strikethroughposition: "strikethroughPosition",
2470			"strikethrough-position": "strikethroughPosition",
2471			strikethroughthickness: "strikethroughThickness",
2472			"strikethrough-thickness": "strikethroughThickness",
2473			string: "string",
2474			stroke: "stroke",
2475			strokedasharray: "strokeDasharray",
2476			"stroke-dasharray": "strokeDasharray",
2477			strokedashoffset: "strokeDashoffset",
2478			"stroke-dashoffset": "strokeDashoffset",
2479			strokelinecap: "strokeLinecap",
2480			"stroke-linecap": "strokeLinecap",
2481			strokelinejoin: "strokeLinejoin",
2482			"stroke-linejoin": "strokeLinejoin",
2483			strokemiterlimit: "strokeMiterlimit",
2484			"stroke-miterlimit": "strokeMiterlimit",
2485			strokewidth: "strokeWidth",
2486			"stroke-width": "strokeWidth",
2487			strokeopacity: "strokeOpacity",
2488			"stroke-opacity": "strokeOpacity",
2489			suppresscontenteditablewarning: "suppressContentEditableWarning",
2490			suppresshydrationwarning: "suppressHydrationWarning",
2491			surfacescale: "surfaceScale",
2492			systemlanguage: "systemLanguage",
2493			tablevalues: "tableValues",
2494			targetx: "targetX",
2495			targety: "targetY",
2496			textanchor: "textAnchor",
2497			"text-anchor": "textAnchor",
2498			textdecoration: "textDecoration",
2499			"text-decoration": "textDecoration",
2500			textlength: "textLength",
2501			textrendering: "textRendering",
2502			"text-rendering": "textRendering",
2503			to: "to",
2504			transform: "transform",
2505			typeof: "typeof",
2506			u1: "u1",
2507			u2: "u2",
2508			underlineposition: "underlinePosition",
2509			"underline-position": "underlinePosition",
2510			underlinethickness: "underlineThickness",
2511			"underline-thickness": "underlineThickness",
2512			unicode: "unicode",
2513			unicodebidi: "unicodeBidi",

2514			"unicode-bidi": "unicodeBidi",
2515			unicoderange: "unicodeRange",
2516			"unicode-range": "unicodeRange",
2517			unitsperem: "unitsPerEm",
2518			"units-per-em": "unitsPerEm",
2519			unselectable: "unselectable",
2520			valphabetic: "vAlphabetic",
2521			"v-alphabetic": "vAlphabetic",
2522			values: "values",
2523			vectoreffect: "vectorEffect",
2524			"vector-effect": "vectorEffect",
2525			version: "version",
2526			vertadvy: "vertAdvY",
2527			"vert-adv-y": "vertAdvY",
2528			vertoriginx: "vertOriginX",
2529			"vert-origin-x": "vertOriginX",
2530			vertoriginy: "vertOriginY",
2531			"vert-origin-y": "vertOriginY",
2532			vhanging: "vHanging",
2533			"v-hanging": "vHanging",
2534			videographic: "vIdeographic",
2535			"v-ideographic": "vIdeographic",
2536			viewbox: "viewBox",
2537			viewtarget: "viewTarget",
2538			visibility: "visibility",
2539			vmathematical: "vMathematical",
2540			"v-mathematical": "vMathematical",
2541			vocab: "vocab",
2542			widths: "widths",
2543			wordspacing: "wordSpacing",
2544			"word-spacing": "wordSpacing",
2545			writingmode: "writingMode",
2546			"writing-mode": "writingMode",
2547			x1: "x1",
2548			x2: "x2",
2549			x: "x",
2550			xchannelselector: "xChannelSelector",
2551			xheight: "xHeight",
2552			"x-height": "xHeight",
2553			xlinkactuate: "xlinkActuate",
2554			"xlink:actuate": "xlinkActuate",
2555			xlinkarcrole: "xlinkArcrole",
2556			"xlink:arcrole": "xlinkArcrole",
2557			xlinkhref: "xlinkHref",
2558			"xlink:href": "xlinkHref",
2559			xlinkrole: "xlinkRole",
2560			"xlink:role": "xlinkRole",
2561			xlinkshow: "xlinkShow",
2562			"xlink:show": "xlinkShow",
2563			xlinktitle: "xlinkTitle",
2564			"xlink:title": "xlinkTitle",
2565			xlinktype: "xlinkType",
2566			"xlink:type": "xlinkType",
2567			xmlbase: "xmlBase",
2568			"xml:base": "xmlBase",
2569			xmllang: "xmlLang",
2570			"xml:lang": "xmlLang",
2571			xmlns: "xmlns",
2572			"xml:space": "xmlSpace",
2573			xmlnsxlink: "xmlnsXlink",
2574			"xmlns:xlink": "xmlnsXlink",
2575			xmlspace: "xmlSpace",
2576			y1: "y1",
2577			y2: "y2",
2578			y: "y",
2579			ychannelselector: "yChannelSelector",
2580			z: "z",
2581			zoomandpan: "zoomAndPan"
2582		};
2583		var ariaProperties = {
2584			"aria-current": 0,
2585			"aria-description": 0,
2586			"aria-details": 0,
2587			"aria-disabled": 0,
2588			"aria-hidden": 0,
2589			"aria-invalid": 0,
2590			"aria-keyshortcuts": 0,
2591			"aria-label": 0,
2592			"aria-roledescription": 0,
2593			"aria-autocomplete": 0,
2594			"aria-checked": 0,
2595			"aria-expanded": 0,
2596			"aria-haspopup": 0,
2597			"aria-level": 0,
2598			"aria-modal": 0,
2599			"aria-multiline": 0,
2600			"aria-multiselectable": 0,
2601			"aria-orientation": 0,
2602			"aria-placeholder": 0,
2603			"aria-pressed": 0,
2604			"aria-readonly": 0,
2605			"aria-required": 0,
2606			"aria-selected": 0,
2607			"aria-sort": 0,
2608			"aria-valuemax": 0,
2609			"aria-valuemin": 0,
2610			"aria-valuenow": 0,
2611			"aria-valuetext": 0,
2612			"aria-atomic": 0,
2613			"aria-busy": 0,
2614			"aria-live": 0,
2615			"aria-relevant": 0,
2616			"aria-dropeffect": 0,
2617			"aria-grabbed": 0,
2618			"aria-activedescendant": 0,
2619			"aria-colcount": 0,
2620			"aria-colindex": 0,
2621			"aria-colspan": 0,
2622			"aria-controls": 0,
2623			"aria-describedby": 0,
2624			"aria-errormessage": 0,
2625			"aria-flowto": 0,
2626			"aria-labelledby": 0,
2627			"aria-owns": 0,
2628			"aria-posinset": 0,
2629			"aria-rowcount": 0,
2630			"aria-rowindex": 0,
2631			"aria-rowspan": 0,
2632			"aria-setsize": 0
2633		};
2634		var warnedProperties = {};
2635		var rARIA = /* @__PURE__ */ new RegExp("^(aria)-[" + ATTRIBUTE_NAME_CHAR + "]*$");
2636		var rARIACamel = /* @__PURE__ */ new RegExp("^(aria)[A-Z][" + ATTRIBUTE_NAME_CHAR + "]*$");
2637		function validateProperty(tagName, name) {
2638			if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) return true;
2639			if (rARIACamel.test(name)) {
2640				var ariaName = "aria-" + name.slice(4).toLowerCase();
2641				var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null;
2642				if (correctName == null) {
2643					error("Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.", name);
2644					warnedProperties[name] = true;
2645					return true;
2646				}
2647				if (name !== correctName) {
2648					error("Invalid ARIA attribute `%s`. Did you mean `%s`?", name, correctName);
2649					warnedProperties[name] = true;
2650					return true;
2651				}
2652			}
2653			if (rARIA.test(name)) {
2654				var lowerCasedName = name.toLowerCase();
2655				var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null;
2656				if (standardName == null) {
2657					warnedProperties[name] = true;
2658					return false;