@@ -2,7028 +2,9876 @@
22 * @license React
33 * react-dom-server-legacy.browser.development.js
44 *
5− * Copyright (c) Facebook, Inc. and its affiliates.
5+ * Copyright (c) Meta Platforms, Inc. and affiliates.
66 *
77 * This source code is licensed under the MIT license found in the
88 * LICENSE file in the root directory of this source tree.
99 */
1010
11−'use strict';
12−
13−if (process.env.NODE_ENV !== "production") {
14− (function() {
15−'use strict';
16−
17−var React = require('react');
18−
19−var ReactVersion = '18.3.1';
20−
21−var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
22−
23−// by calls to these methods by a Babel plugin.
24−//
25−// In PROD (or in packages without access to React internals),
26−// they are left as they are instead.
27−
28−function warn(format) {
29− {
30− {
31− for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
32− args[_key - 1] = arguments[_key];
33− }
34−
35− printWarning('warn', format, args);
36− }
37− }
38−}
39−function error(format) {
40− {
41− {
42− for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
43− args[_key2 - 1] = arguments[_key2];
44− }
45−
46− printWarning('error', format, args);
47− }
48− }
49−}
50−
51−function printWarning(level, format, args) {
52− // When changing this logic, you might want to also
53− // update consoleWithStackDev.www.js as well.
54− {
55− var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
56− var stack = ReactDebugCurrentFrame.getStackAddendum();
57−
58− if (stack !== '') {
59− format += '%s';
60− args = args.concat([stack]);
61− } // eslint-disable-next-line react-internal/safe-string-coercion
62−
63−
64− var argsWithFormat = args.map(function (item) {
65− return String(item);
66− }); // Careful: RN currently depends on this prefix
67−
68− argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
69− // breaks IE9: https://github.com/facebook/react/issues/13610
70− // eslint-disable-next-line react-internal/no-production-logging
71−
72− Function.prototype.apply.call(console[level], console, argsWithFormat);
73− }
74−}
75−
76−function scheduleWork(callback) {
77− callback();
78−}
79−function beginWriting(destination) {}
80−function writeChunk(destination, chunk) {
81− writeChunkAndReturn(destination, chunk);
82−}
83−function writeChunkAndReturn(destination, chunk) {
84− return destination.push(chunk);
85−}
86−function completeWriting(destination) {}
87−function close(destination) {
88− destination.push(null);
89−}
90−function stringToChunk(content) {
91− return content;
92−}
93−function stringToPrecomputedChunk(content) {
94− return content;
95−}
96−function closeWithError(destination, error) {
97− // $FlowFixMe: This is an Error object or the destination accepts other types.
98− destination.destroy(error);
99−}
100−
10111/*
102− * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
103− * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
104− *
105− * The functions in this module will throw an easier-to-understand,
106− * easier-to-debug exception with a clear errors message message explaining the
107− * problem. (Instead of a confusing exception thrown inside the implementation
108− * of the `value` object).
109− */
110−// $FlowFixMe only called in DEV, so void return is not possible.
111−function typeName(value) {
112− {
113− // toStringTag is needed for namespaced types like Temporal.Instant
114− var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
115− var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
116− return type;
117− }
118−} // $FlowFixMe only called in DEV, so void return is not possible.
119−
120−
121−function willCoercionThrow(value) {
122− {
123− try {
124− testStringCoercion(value);
125− return false;
126− } catch (e) {
127− return true;
128− }
129− }
130−}
131−
132−function testStringCoercion(value) {
133− // If you ended up here by following an exception call stack, here's what's
134− // happened: you supplied an object or symbol value to React (as a prop, key,
135− // DOM attribute, CSS property, string ref, etc.) and when React tried to
136− // coerce it to a string using `'' + value`, an exception was thrown.
137− //
138− // The most common types that will cause this exception are `Symbol` instances
139− // and Temporal objects like `Temporal.Instant`. But any object that has a
140− // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
141− // exception. (Library authors do this to prevent users from using built-in
142− // numeric operators like `+` or comparison operators like `>=` because custom
143− // methods are needed to perform accurate arithmetic or comparison.)
144− //
145− // To fix the problem, coerce this object or symbol value to a string before
146− // passing it to React. The most reliable way is usually `String(value)`.
147− //
148− // To find which value is throwing, check the browser or debugger console.
149− // Before this exception was thrown, there should be `console.error` output
150− // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
151− // problem and how that type was used: key, atrribute, input value prop, etc.
152− // In most cases, this console output also shows the component and its
153− // ancestor components where the exception happened.
154− //
155− // eslint-disable-next-line react-internal/safe-string-coercion
156− return '' + value;
157−}
158−
159−function checkAttributeStringCoercion(value, attributeName) {
160− {
161− if (willCoercionThrow(value)) {
162− 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));
163−
164− return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
165− }
166− }
167−}
168−function checkCSSPropertyStringCoercion(value, propName) {
169− {
170− if (willCoercionThrow(value)) {
171− 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));
172−
173− return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
174− }
175− }
176−}
177−function checkHtmlStringCoercion(value) {
178− {
179− if (willCoercionThrow(value)) {
180− 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));
181−
182− return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
183− }
184− }
185−}
186−
187−var hasOwnProperty = Object.prototype.hasOwnProperty;
188−
189−// A reserved attribute.
190−// It is handled by React separately and shouldn't be written to the DOM.
191−var RESERVED = 0; // A simple string attribute.
192−// Attributes that aren't in the filter are presumed to have this type.
193−
194−var STRING = 1; // A string attribute that accepts booleans in React. In HTML, these are called
195−// "enumerated" attributes with "true" and "false" as possible values.
196−// When true, it should be set to a "true" string.
197−// When false, it should be set to a "false" string.
19812
199−var BOOLEANISH_STRING = 2; // A real boolean attribute.
200−// When true, it should be present (set either to an empty string or its name).
201−// When false, it should be omitted.
20213
203−var BOOLEAN = 3; // An attribute that can be used as a flag as well as with a value.
204−// When true, it should be present (set either to an empty string or its name).
205−// When false, it should be omitted.
206−// For any other value, should be present with that value.
207−
208−var OVERLOADED_BOOLEAN = 4; // An attribute that must be numeric or parse as a numeric.
209−// When falsy, it should be removed.
210−
211−var NUMERIC = 5; // An attribute that must be positive numeric or parse as a positive numeric.
212−// When falsy, it should be removed.
213−
214−var POSITIVE_NUMERIC = 6;
215−
216−/* eslint-disable max-len */
217−var ATTRIBUTE_NAME_START_CHAR = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
218−/* eslint-enable max-len */
219−
220−var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
221−var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
222−var illegalAttributeNameCache = {};
223−var validatedAttributeNameCache = {};
224−function isAttributeNameSafe(attributeName) {
225− if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
226− return true;
227− }
228−
229− if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
230− return false;
231− }
232−
233− if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
234− validatedAttributeNameCache[attributeName] = true;
235− return true;
236− }
237−
238− illegalAttributeNameCache[attributeName] = true;
239−
240− {
241− error('Invalid attribute name: `%s`', attributeName);
242− }
243−
244− return false;
245−}
246−function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) {
247− if (propertyInfo !== null && propertyInfo.type === RESERVED) {
248− return false;
249− }
250−
251− switch (typeof value) {
252− case 'function': // $FlowIssue symbol is perfectly valid here
253−
254− case 'symbol':
255− // eslint-disable-line
256− return true;
257−
258− case 'boolean':
259− {
260− if (isCustomComponentTag) {
261− return false;
14+ JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
15+
16+ Copyright (c) 2011 Gary Court
17+ Permission is hereby granted, free of charge, to any person obtaining a copy
18+ of this software and associated documentation files (the "Software"), to deal
19+ in the Software without restriction, including without limitation the rights
20+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
21+ copies of the Software, and to permit persons to whom the Software is
22+ furnished to do so, subject to the following conditions:
23+
24+ The above copyright notice and this permission notice shall be included in
25+ all copies or substantial portions of the Software.
26+
27+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
30+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
31+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
32+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33+ SOFTWARE.
34+*/
35+"use strict";
36+"production" !== process.env.NODE_ENV &&
37+ (function () {
38+ function styleReplacer(match, prefix, s, suffix) {
39+ return "" + prefix + ("s" === s ? "\\73 " : "\\53 ") + suffix;
40+ }
41+ function scriptReplacer(match, prefix, s, suffix) {
42+ return "" + prefix + ("s" === s ? "\\u0073" : "\\u0053") + suffix;
43+ }
44+ function getIteratorFn(maybeIterable) {
45+ if (null === maybeIterable || "object" !== typeof maybeIterable)
46+ return null;
47+ maybeIterable =
48+ (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
49+ maybeIterable["@@iterator"];
50+ return "function" === typeof maybeIterable ? maybeIterable : null;
51+ }
52+ function objectName(object) {
53+ object = Object.prototype.toString.call(object);
54+ return object.slice(8, object.length - 1);
55+ }
56+ function describeKeyForErrorMessage(key) {
57+ var encodedKey = JSON.stringify(key);
58+ return '"' + key + '"' === encodedKey ? key : encodedKey;
59+ }
60+ function describeValueForErrorMessage(value) {
61+ switch (typeof value) {
62+ case "string":
63+ return JSON.stringify(
64+ 10 >= value.length ? value : value.slice(0, 10) + "..."
65+ );
66+ case "object":
67+ if (isArrayImpl(value)) return "[...]";
68+ if (null !== value && value.$$typeof === CLIENT_REFERENCE_TAG)
69+ return "client";
70+ value = objectName(value);
71+ return "Object" === value ? "{...}" : value;
72+ case "function":
73+ return value.$$typeof === CLIENT_REFERENCE_TAG
74+ ? "client"
75+ : (value = value.displayName || value.name)
76+ ? "function " + value
77+ : "function";
78+ default:
79+ return String(value);
80+ }
81+ }
82+ function describeElementType(type) {
83+ if ("string" === typeof type) return type;
84+ switch (type) {
85+ case REACT_SUSPENSE_TYPE:
86+ return "Suspense";
87+ case REACT_SUSPENSE_LIST_TYPE:
88+ return "SuspenseList";
89+ }
90+ if ("object" === typeof type)
91+ switch (type.$$typeof) {
92+ case REACT_FORWARD_REF_TYPE:
93+ return describeElementType(type.render);
94+ case REACT_MEMO_TYPE:
95+ return describeElementType(type.type);
96+ case REACT_LAZY_TYPE:
97+ var payload = type._payload;
98+ type = type._init;
99+ try {
100+ return describeElementType(type(payload));
101+ } catch (x) {}
262102 }
263−
264− if (propertyInfo !== null) {
265− return !propertyInfo.acceptsBooleans;
103+ return "";
104+ }
105+ function describeObjectForErrorMessage(objectOrArray, expandedName) {
106+ var objKind = objectName(objectOrArray);
107+ if ("Object" !== objKind && "Array" !== objKind) return objKind;
108+ var start = -1,
109+ length = 0;
110+ if (isArrayImpl(objectOrArray))
111+ if (jsxChildrenParents.has(objectOrArray)) {
112+ var type = jsxChildrenParents.get(objectOrArray);
113+ objKind = "<" + describeElementType(type) + ">";
114+ for (var i = 0; i < objectOrArray.length; i++) {
115+ var value = objectOrArray[i];
116+ value =
117+ "string" === typeof value
118+ ? value
119+ : "object" === typeof value && null !== value
120+ ? "{" + describeObjectForErrorMessage(value) + "}"
121+ : "{" + describeValueForErrorMessage(value) + "}";
122+ "" + i === expandedName
123+ ? ((start = objKind.length),
124+ (length = value.length),
125+ (objKind += value))
126+ : (objKind =
127+ 15 > value.length && 40 > objKind.length + value.length
128+ ? objKind + value
129+ : objKind + "{...}");
130+ }
131+ objKind += "</" + describeElementType(type) + ">";
266132 } else {
267− var prefix = name.toLowerCase().slice(0, 5);
268− return prefix !== 'data-' && prefix !== 'aria-';
133+ objKind = "[";
134+ for (type = 0; type < objectOrArray.length; type++)
135+ 0 < type && (objKind += ", "),
136+ (i = objectOrArray[type]),
137+ (i =
138+ "object" === typeof i && null !== i
139+ ? describeObjectForErrorMessage(i)
140+ : describeValueForErrorMessage(i)),
141+ "" + type === expandedName
142+ ? ((start = objKind.length),
143+ (length = i.length),
144+ (objKind += i))
145+ : (objKind =
146+ 10 > i.length && 40 > objKind.length + i.length
147+ ? objKind + i
148+ : objKind + "...");
149+ objKind += "]";
150+ }
151+ else if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE)
152+ objKind = "<" + describeElementType(objectOrArray.type) + "/>";
153+ else {
154+ if (objectOrArray.$$typeof === CLIENT_REFERENCE_TAG) return "client";
155+ if (jsxPropsParents.has(objectOrArray)) {
156+ objKind = jsxPropsParents.get(objectOrArray);
157+ objKind = "<" + (describeElementType(objKind) || "...");
158+ type = Object.keys(objectOrArray);
159+ for (i = 0; i < type.length; i++) {
160+ objKind += " ";
161+ value = type[i];
162+ objKind += describeKeyForErrorMessage(value) + "=";
163+ var _value2 = objectOrArray[value];
164+ var _substr2 =
165+ value === expandedName &&
166+ "object" === typeof _value2 &&
167+ null !== _value2
168+ ? describeObjectForErrorMessage(_value2)
169+ : describeValueForErrorMessage(_value2);
170+ "string" !== typeof _value2 && (_substr2 = "{" + _substr2 + "}");
171+ value === expandedName
172+ ? ((start = objKind.length),
173+ (length = _substr2.length),
174+ (objKind += _substr2))
175+ : (objKind =
176+ 10 > _substr2.length && 40 > objKind.length + _substr2.length
177+ ? objKind + _substr2
178+ : objKind + "...");
179+ }
180+ objKind += ">";
181+ } else {
182+ objKind = "{";
183+ type = Object.keys(objectOrArray);
184+ for (i = 0; i < type.length; i++)
185+ 0 < i && (objKind += ", "),
186+ (value = type[i]),
187+ (objKind += describeKeyForErrorMessage(value) + ": "),
188+ (_value2 = objectOrArray[value]),
189+ (_value2 =
190+ "object" === typeof _value2 && null !== _value2
191+ ? describeObjectForErrorMessage(_value2)
192+ : describeValueForErrorMessage(_value2)),
193+ value === expandedName
194+ ? ((start = objKind.length),
195+ (length = _value2.length),
196+ (objKind += _value2))
197+ : (objKind =
198+ 10 > _value2.length && 40 > objKind.length + _value2.length
199+ ? objKind + _value2
200+ : objKind + "...");
201+ objKind += "}";
269202 }
270203 }
271−
272− default:
273− return false;
274− }
275−}
276−function getPropertyInfo(name) {
277− return properties.hasOwnProperty(name) ? properties[name] : null;
278−}
279−
280−function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL, removeEmptyString) {
281− this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN;
282− this.attributeName = attributeName;
283− this.attributeNamespace = attributeNamespace;
284− this.mustUseProperty = mustUseProperty;
285− this.propertyName = name;
286− this.type = type;
287− this.sanitizeURL = sanitizeURL;
288− this.removeEmptyString = removeEmptyString;
289−} // When adding attributes to this list, be sure to also add them to
290−// the `possibleStandardNames` module to ensure casing and incorrect
291−// name warnings.
292−
293−
294−var properties = {}; // These props are reserved by React. They shouldn't be written to the DOM.
295−
296−var reservedProps = ['children', 'dangerouslySetInnerHTML', // TODO: This prevents the assignment of defaultValue to regular
297−// elements (not just inputs). Now that ReactDOMInput assigns to the
298−// defaultValue property -- do we need this?
299−'defaultValue', 'defaultChecked', 'innerHTML', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'style'];
300−
301−reservedProps.forEach(function (name) {
302− properties[name] = new PropertyInfoRecord(name, RESERVED, false, // mustUseProperty
303− name, // attributeName
304− null, // attributeNamespace
305− false, // sanitizeURL
306− false);
307−}); // A few React string attributes have a different name.
308−// This is a mapping from React prop names to the attribute names.
309−
310−[['acceptCharset', 'accept-charset'], ['className', 'class'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv']].forEach(function (_ref) {
311− var name = _ref[0],
312− attributeName = _ref[1];
313− properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty
314− attributeName, // attributeName
315− null, // attributeNamespace
316− false, // sanitizeURL
317− false);
318−}); // These are "enumerated" HTML attributes that accept "true" and "false".
319−// In React, we let users pass `true` and `false` even though technically
320−// these aren't boolean attributes (they are coerced to strings).
321−
322−['contentEditable', 'draggable', 'spellCheck', 'value'].forEach(function (name) {
323− properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty
324− name.toLowerCase(), // attributeName
325− null, // attributeNamespace
326− false, // sanitizeURL
327− false);
328−}); // These are "enumerated" SVG attributes that accept "true" and "false".
329−// In React, we let users pass `true` and `false` even though technically
330−// these aren't boolean attributes (they are coerced to strings).
331−// Since these are SVG attributes, their attribute names are case-sensitive.
332−
333−['autoReverse', 'externalResourcesRequired', 'focusable', 'preserveAlpha'].forEach(function (name) {
334− properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty
335− name, // attributeName
336− null, // attributeNamespace
337− false, // sanitizeURL
338− false);
339−}); // These are HTML boolean attributes.
340−
341−['allowFullScreen', 'async', // Note: there is a special case that prevents it from being written to the DOM
342−// on the client side because the browsers are inconsistent. Instead we call focus().
343−'autoFocus', 'autoPlay', 'controls', 'default', 'defer', 'disabled', 'disablePictureInPicture', 'disableRemotePlayback', 'formNoValidate', 'hidden', 'loop', 'noModule', 'noValidate', 'open', 'playsInline', 'readOnly', 'required', 'reversed', 'scoped', 'seamless', // Microdata
344−'itemScope'].forEach(function (name) {
345− properties[name] = new PropertyInfoRecord(name, BOOLEAN, false, // mustUseProperty
346− name.toLowerCase(), // attributeName
347− null, // attributeNamespace
348− false, // sanitizeURL
349− false);
350−}); // These are the few React props that we set as DOM properties
351−// rather than attributes. These are all booleans.
352−
353−['checked', // Note: `option.selected` is not updated if `select.multiple` is
354−// disabled with `removeAttribute`. We have special logic for handling this.
355−'multiple', 'muted', 'selected' // NOTE: if you add a camelCased prop to this list,
356−// you'll need to set attributeName to name.toLowerCase()
357−// instead in the assignment below.
358−].forEach(function (name) {
359− properties[name] = new PropertyInfoRecord(name, BOOLEAN, true, // mustUseProperty
360− name, // attributeName
361− null, // attributeNamespace
362− false, // sanitizeURL
363− false);
364−}); // These are HTML attributes that are "overloaded booleans": they behave like
365−// booleans, but can also accept a string value.
366−
367−['capture', 'download' // NOTE: if you add a camelCased prop to this list,
368−// you'll need to set attributeName to name.toLowerCase()
369−// instead in the assignment below.
370−].forEach(function (name) {
371− properties[name] = new PropertyInfoRecord(name, OVERLOADED_BOOLEAN, false, // mustUseProperty
372− name, // attributeName
373− null, // attributeNamespace
374− false, // sanitizeURL
375− false);
376−}); // These are HTML attributes that must be positive numbers.
377−
378−['cols', 'rows', 'size', 'span' // NOTE: if you add a camelCased prop to this list,
379−// you'll need to set attributeName to name.toLowerCase()
380−// instead in the assignment below.
381−].forEach(function (name) {
382− properties[name] = new PropertyInfoRecord(name, POSITIVE_NUMERIC, false, // mustUseProperty
383− name, // attributeName
384− null, // attributeNamespace
385− false, // sanitizeURL
386− false);
387−}); // These are HTML attributes that must be numbers.
388−
389−['rowSpan', 'start'].forEach(function (name) {
390− properties[name] = new PropertyInfoRecord(name, NUMERIC, false, // mustUseProperty
391− name.toLowerCase(), // attributeName
392− null, // attributeNamespace
393− false, // sanitizeURL
394− false);
395−});
396−var CAMELIZE = /[\-\:]([a-z])/g;
397−
398−var capitalize = function (token) {
399− return token[1].toUpperCase();
400−}; // This is a list of all SVG attributes that need special casing, namespacing,
401−// or boolean value assignment. Regular attributes that just accept strings
402−// and have the same names are omitted, just like in the HTML attribute filter.
403−// Some of these attributes can be hard to find. This list was created by
404−// scraping the MDN documentation.
405−
406−
407−['accent-height', 'alignment-baseline', 'arabic-form', 'baseline-shift', 'cap-height', 'clip-path', 'clip-rule', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'dominant-baseline', 'enable-background', 'fill-opacity', 'fill-rule', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'glyph-name', 'glyph-orientation-horizontal', 'glyph-orientation-vertical', 'horiz-adv-x', 'horiz-origin-x', 'image-rendering', 'letter-spacing', 'lighting-color', 'marker-end', 'marker-mid', 'marker-start', 'overline-position', 'overline-thickness', 'paint-order', 'panose-1', 'pointer-events', 'rendering-intent', 'shape-rendering', 'stop-color', 'stop-opacity', 'strikethrough-position', 'strikethrough-thickness', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'text-anchor', 'text-decoration', 'text-rendering', 'underline-position', 'underline-thickness', 'unicode-bidi', 'unicode-range', 'units-per-em', 'v-alphabetic', 'v-hanging', 'v-ideographic', 'v-mathematical', 'vector-effect', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'word-spacing', 'writing-mode', 'xmlns:xlink', 'x-height' // NOTE: if you add a camelCased prop to this list,
408−// you'll need to set attributeName to name.toLowerCase()
409−// instead in the assignment below.
410−].forEach(function (attributeName) {
411− var name = attributeName.replace(CAMELIZE, capitalize);
412− properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty
413− attributeName, null, // attributeNamespace
414− false, // sanitizeURL
415− false);
416−}); // String SVG attributes with the xlink namespace.
417−
418−['xlink:actuate', 'xlink:arcrole', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type' // NOTE: if you add a camelCased prop to this list,
419−// you'll need to set attributeName to name.toLowerCase()
420−// instead in the assignment below.
421−].forEach(function (attributeName) {
422− var name = attributeName.replace(CAMELIZE, capitalize);
423− properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty
424− attributeName, 'http://www.w3.org/1999/xlink', false, // sanitizeURL
425− false);
426−}); // String SVG attributes with the xml namespace.
427−
428−['xml:base', 'xml:lang', 'xml:space' // NOTE: if you add a camelCased prop to this list,
429−// you'll need to set attributeName to name.toLowerCase()
430−// instead in the assignment below.
431−].forEach(function (attributeName) {
432− var name = attributeName.replace(CAMELIZE, capitalize);
433− properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty
434− attributeName, 'http://www.w3.org/XML/1998/namespace', false, // sanitizeURL
435− false);
436−}); // These attribute exists both in HTML and SVG.
437−// The attribute name is case-sensitive in SVG so we can't just use
438−// the React name like we do for attributes that exist only in HTML.
439−
440−['tabIndex', 'crossOrigin'].forEach(function (attributeName) {
441− properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, // mustUseProperty
442− attributeName.toLowerCase(), // attributeName
443− null, // attributeNamespace
444− false, // sanitizeURL
445− false);
446−}); // These attributes accept URLs. These must not allow javascript: URLS.
447−// These will also need to accept Trusted Types object in the future.
448−
449−var xlinkHref = 'xlinkHref';
450−properties[xlinkHref] = new PropertyInfoRecord('xlinkHref', STRING, false, // mustUseProperty
451−'xlink:href', 'http://www.w3.org/1999/xlink', true, // sanitizeURL
452−false);
453−['src', 'href', 'action', 'formAction'].forEach(function (attributeName) {
454− properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, // mustUseProperty
455− attributeName.toLowerCase(), // attributeName
456− null, // attributeNamespace
457− true, // sanitizeURL
458− true);
459−});
460−
461−/**
462− * CSS properties which accept numbers but are not in units of "px".
463− */
464−var isUnitlessNumber = {
465− animationIterationCount: true,
466− aspectRatio: true,
467− borderImageOutset: true,
468− borderImageSlice: true,
469− borderImageWidth: true,
470− boxFlex: true,
471− boxFlexGroup: true,
472− boxOrdinalGroup: true,
473− columnCount: true,
474− columns: true,
475− flex: true,
476− flexGrow: true,
477− flexPositive: true,
478− flexShrink: true,
479− flexNegative: true,
480− flexOrder: true,
481− gridArea: true,
482− gridRow: true,
483− gridRowEnd: true,
484− gridRowSpan: true,
485− gridRowStart: true,
486− gridColumn: true,
487− gridColumnEnd: true,
488− gridColumnSpan: true,
489− gridColumnStart: true,
490− fontWeight: true,
491− lineClamp: true,
492− lineHeight: true,
493− opacity: true,
494− order: true,
495− orphans: true,
496− tabSize: true,
497− widows: true,
498− zIndex: true,
499− zoom: true,
500− // SVG-related properties
501− fillOpacity: true,
502− floodOpacity: true,
503− stopOpacity: true,
504− strokeDasharray: true,
505− strokeDashoffset: true,
506− strokeMiterlimit: true,
507− strokeOpacity: true,
508− strokeWidth: true
509−};
510−/**
511− * @param {string} prefix vendor-specific prefix, eg: Webkit
512− * @param {string} key style name, eg: transitionDuration
513− * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
514− * WebkitTransitionDuration
515− */
516−
517−function prefixKey(prefix, key) {
518− return prefix + key.charAt(0).toUpperCase() + key.substring(1);
519−}
520−/**
521− * Support style names that may come passed in prefixed by adding permutations
522− * of vendor prefixes.
523− */
524−
525−
526−var prefixes = ['Webkit', 'ms', 'Moz', 'O']; // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
527−// infinite loop, because it iterates over the newly added props too.
528−
529−Object.keys(isUnitlessNumber).forEach(function (prop) {
530− prefixes.forEach(function (prefix) {
531− isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
532− });
533−});
534−
535−var hasReadOnlyValue = {
536− button: true,
537− checkbox: true,
538− image: true,
539− hidden: true,
540− radio: true,
541− reset: true,
542− submit: true
543−};
544−function checkControlledValueProps(tagName, props) {
545− {
546− if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
547− 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`.');
548− }
549−
550− if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
551− 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`.');
552− }
553− }
554−}
555−
556−function isCustomComponent(tagName, props) {
557− if (tagName.indexOf('-') === -1) {
558− return typeof props.is === 'string';
559− }
560−
561− switch (tagName) {
562− // These are reserved SVG and MathML elements.
563− // We don't mind this list too much because we expect it to never grow.
564− // The alternative is to track the namespace in a few places which is convoluted.
565− // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
566− case 'annotation-xml':
567− case 'color-profile':
568− case 'font-face':
569− case 'font-face-src':
570− case 'font-face-uri':
571− case 'font-face-format':
572− case 'font-face-name':
573− case 'missing-glyph':
574− return false;
575−
576− default:
577− return true;
578− }
579−}
580−
581−var ariaProperties = {
582− 'aria-current': 0,
583− // state
584− 'aria-description': 0,
585− 'aria-details': 0,
586− 'aria-disabled': 0,
587− // state
588− 'aria-hidden': 0,
589− // state
590− 'aria-invalid': 0,
591− // state
592− 'aria-keyshortcuts': 0,
593− 'aria-label': 0,
594− 'aria-roledescription': 0,
595− // Widget Attributes
596− 'aria-autocomplete': 0,
597− 'aria-checked': 0,
598− 'aria-expanded': 0,
599− 'aria-haspopup': 0,
600− 'aria-level': 0,
601− 'aria-modal': 0,
602− 'aria-multiline': 0,
603− 'aria-multiselectable': 0,
604− 'aria-orientation': 0,
605− 'aria-placeholder': 0,
606− 'aria-pressed': 0,
607− 'aria-readonly': 0,
608− 'aria-required': 0,
609− 'aria-selected': 0,
610− 'aria-sort': 0,
611− 'aria-valuemax': 0,
612− 'aria-valuemin': 0,
613− 'aria-valuenow': 0,
614− 'aria-valuetext': 0,
615− // Live Region Attributes
616− 'aria-atomic': 0,
617− 'aria-busy': 0,
618− 'aria-live': 0,
619− 'aria-relevant': 0,
620− // Drag-and-Drop Attributes
621− 'aria-dropeffect': 0,
622− 'aria-grabbed': 0,
623− // Relationship Attributes
624− 'aria-activedescendant': 0,
625− 'aria-colcount': 0,
626− 'aria-colindex': 0,
627− 'aria-colspan': 0,
628− 'aria-controls': 0,
629− 'aria-describedby': 0,
630− 'aria-errormessage': 0,
631− 'aria-flowto': 0,
632− 'aria-labelledby': 0,
633− 'aria-owns': 0,
634− 'aria-posinset': 0,
635− 'aria-rowcount': 0,
636− 'aria-rowindex': 0,
637− 'aria-rowspan': 0,
638− 'aria-setsize': 0
639−};
640−
641−var warnedProperties = {};
642−var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
643−var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
644−
645−function validateProperty(tagName, name) {
646− {
647− if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
648− return true;
649− }
650−
651− if (rARIACamel.test(name)) {
652− var ariaName = 'aria-' + name.slice(4).toLowerCase();
653− var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
654− // DOM properties, then it is an invalid aria-* attribute.
655−
656− if (correctName == null) {
657− error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
658−
659− warnedProperties[name] = true;
660− return true;
661− } // aria-* attributes should be lowercase; suggest the lowercase version.
662−
663−
664− if (name !== correctName) {
665− error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
666−
667− warnedProperties[name] = true;
668− return true;
669− }
670− }
671−
672− if (rARIA.test(name)) {
204+ return void 0 === expandedName
205+ ? objKind
206+ : -1 < start && 0 < length
207+ ? ((objectOrArray = " ".repeat(start) + "^".repeat(length)),
208+ "\n " + objKind + "\n " + objectOrArray)
209+ : "\n " + objKind;
210+ }
211+ function murmurhash3_32_gc(key, seed) {
212+ var remainder = key.length & 3;
213+ var bytes = key.length - remainder;
214+ var h1 = seed;
215+ for (seed = 0; seed < bytes; ) {
216+ var k1 =
217+ (key.charCodeAt(seed) & 255) |
218+ ((key.charCodeAt(++seed) & 255) << 8) |
219+ ((key.charCodeAt(++seed) & 255) << 16) |
220+ ((key.charCodeAt(++seed) & 255) << 24);
221+ ++seed;
222+ k1 =
223+ (3432918353 * (k1 & 65535) +
224+ (((3432918353 * (k1 >>> 16)) & 65535) << 16)) &
225+ 4294967295;
226+ k1 = (k1 << 15) | (k1 >>> 17);
227+ k1 =
228+ (461845907 * (k1 & 65535) +
229+ (((461845907 * (k1 >>> 16)) & 65535) << 16)) &
230+ 4294967295;
231+ h1 ^= k1;
232+ h1 = (h1 << 13) | (h1 >>> 19);
233+ h1 =
234+ (5 * (h1 & 65535) + (((5 * (h1 >>> 16)) & 65535) << 16)) & 4294967295;
235+ h1 = (h1 & 65535) + 27492 + ((((h1 >>> 16) + 58964) & 65535) << 16);
236+ }
237+ k1 = 0;
238+ switch (remainder) {
239+ case 3:
240+ k1 ^= (key.charCodeAt(seed + 2) & 255) << 16;
241+ case 2:
242+ k1 ^= (key.charCodeAt(seed + 1) & 255) << 8;
243+ case 1:
244+ (k1 ^= key.charCodeAt(seed) & 255),
245+ (k1 =
246+ (3432918353 * (k1 & 65535) +
247+ (((3432918353 * (k1 >>> 16)) & 65535) << 16)) &
248+ 4294967295),
249+ (k1 = (k1 << 15) | (k1 >>> 17)),
250+ (h1 ^=
251+ (461845907 * (k1 & 65535) +
252+ (((461845907 * (k1 >>> 16)) & 65535) << 16)) &
253+ 4294967295);
254+ }
255+ h1 ^= key.length;
256+ h1 ^= h1 >>> 16;
257+ h1 =
258+ (2246822507 * (h1 & 65535) +
259+ (((2246822507 * (h1 >>> 16)) & 65535) << 16)) &
260+ 4294967295;
261+ h1 ^= h1 >>> 13;
262+ h1 =
263+ (3266489909 * (h1 & 65535) +
264+ (((3266489909 * (h1 >>> 16)) & 65535) << 16)) &
265+ 4294967295;
266+ return (h1 ^ (h1 >>> 16)) >>> 0;
267+ }
268+ function typeName(value) {
269+ return (
270+ ("function" === typeof Symbol &&
271+ Symbol.toStringTag &&
272+ value[Symbol.toStringTag]) ||
273+ value.constructor.name ||
274+ "Object"
275+ );
276+ }
277+ function willCoercionThrow(value) {
278+ try {
279+ return testStringCoercion(value), !1;
280+ } catch (e) {
281+ return !0;
282+ }
283+ }
284+ function testStringCoercion(value) {
285+ return "" + value;
286+ }
287+ function checkAttributeStringCoercion(value, attributeName) {
288+ if (willCoercionThrow(value))
289+ return (
290+ console.error(
291+ "The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before using it here.",
292+ attributeName,
293+ typeName(value)
294+ ),
295+ testStringCoercion(value)
296+ );
297+ }
298+ function checkCSSPropertyStringCoercion(value, propName) {
299+ if (willCoercionThrow(value))
300+ return (
301+ console.error(
302+ "The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before using it here.",
303+ propName,
304+ typeName(value)
305+ ),
306+ testStringCoercion(value)
307+ );
308+ }
309+ function checkHtmlStringCoercion(value) {
310+ if (willCoercionThrow(value))
311+ return (
312+ console.error(
313+ "The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before using it here.",
314+ typeName(value)
315+ ),
316+ testStringCoercion(value)
317+ );
318+ }
319+ function isAttributeNameSafe(attributeName) {
320+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName))
321+ return !0;
322+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName))
323+ return !1;
324+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName))
325+ return (validatedAttributeNameCache[attributeName] = !0);
326+ illegalAttributeNameCache[attributeName] = !0;
327+ console.error("Invalid attribute name: `%s`", attributeName);
328+ return !1;
329+ }
330+ function checkControlledValueProps(tagName, props) {
331+ hasReadOnlyValue[props.type] ||
332+ props.onChange ||
333+ props.onInput ||
334+ props.readOnly ||
335+ props.disabled ||
336+ null == props.value ||
337+ ("select" === tagName
338+ ? console.error(
339+ "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 `onChange`."
340+ )
341+ : console.error(
342+ "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`."
343+ ));
344+ props.onChange ||
345+ props.readOnly ||
346+ props.disabled ||
347+ null == props.checked ||
348+ console.error(
349+ "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`."
350+ );
351+ }
352+ function validateProperty$1(tagName, name) {
353+ if (
354+ hasOwnProperty.call(warnedProperties$1, name) &&
355+ warnedProperties$1[name]
356+ )
357+ return !0;
358+ if (rARIACamel$1.test(name)) {
359+ tagName = "aria-" + name.slice(4).toLowerCase();
360+ tagName = ariaProperties.hasOwnProperty(tagName) ? tagName : null;
361+ if (null == tagName)
362+ return (
363+ console.error(
364+ "Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.",
365+ name
366+ ),
367+ (warnedProperties$1[name] = !0)
368+ );
369+ if (name !== tagName)
370+ return (
371+ console.error(
372+ "Invalid ARIA attribute `%s`. Did you mean `%s`?",
373+ name,
374+ tagName
375+ ),
376+ (warnedProperties$1[name] = !0)
377+ );
378+ }
379+ if (rARIA$1.test(name)) {
380+ tagName = name.toLowerCase();
381+ tagName = ariaProperties.hasOwnProperty(tagName) ? tagName : null;
382+ if (null == tagName) return (warnedProperties$1[name] = !0), !1;
383+ name !== tagName &&
384+ (console.error(
385+ "Unknown ARIA attribute `%s`. Did you mean `%s`?",
386+ name,
387+ tagName
388+ ),
389+ (warnedProperties$1[name] = !0));
390+ }
391+ return !0;
392+ }
393+ function validateProperties$2(type, props) {
394+ var invalidProps = [],
395+ key;
396+ for (key in props)
397+ validateProperty$1(type, key) || invalidProps.push(key);
398+ props = invalidProps
399+ .map(function (prop) {
400+ return "`" + prop + "`";
401+ })
402+ .join(", ");
403+ 1 === invalidProps.length
404+ ? console.error(
405+ "Invalid aria prop %s on <%s> tag. For details, see https://react.dev/link/invalid-aria-props",
406+ props,
407+ type
408+ )
409+ : 1 < invalidProps.length &&
410+ console.error(
411+ "Invalid aria props %s on <%s> tag. For details, see https://react.dev/link/invalid-aria-props",
412+ props,
413+ type
414+ );
415+ }
416+ function validateProperty(tagName, name, value, eventRegistry) {
417+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name])
418+ return !0;
673419 var lowerCasedName = name.toLowerCase();
674− var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
675− // DOM properties, then it is an invalid aria-* attribute.
676−
677− if (standardName == null) {
678− warnedProperties[name] = true;
679− return false;
680− } // aria-* attributes should be lowercase; suggest the lowercase version.
681−
682−
683− if (name !== standardName) {
684− error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
685−
686− warnedProperties[name] = true;
687− return true;
688− }
689− }
690− }
691−
692− return true;
693−}
694−
695−function warnInvalidARIAProps(type, props) {
696− {
697− var invalidProps = [];
698−
699− for (var key in props) {
700− var isValid = validateProperty(type, key);
701−
702− if (!isValid) {
703− invalidProps.push(key);
704− }
705− }
706−
707− var unknownPropString = invalidProps.map(function (prop) {
708− return '`' + prop + '`';
709− }).join(', ');
710−
711− if (invalidProps.length === 1) {
712− error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
713− } else if (invalidProps.length > 1) {
714− error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
715− }
716− }
717−}
718−
719−function validateProperties(type, props) {
720− if (isCustomComponent(type, props)) {
721− return;
722− }
723−
724− warnInvalidARIAProps(type, props);
725−}
726−
727−var didWarnValueNull = false;
728−function validateProperties$1(type, props) {
729− {
730− if (type !== 'input' && type !== 'textarea' && type !== 'select') {
731− return;
732− }
733−
734− if (props != null && props.value === null && !didWarnValueNull) {
735− didWarnValueNull = true;
736−
737− if (type === 'select' && props.multiple) {
738− error('`value` prop on `%s` should not be null. ' + 'Consider using an empty array when `multiple` is set to `true` ' + 'to clear the component or `undefined` for uncontrolled components.', type);
739− } else {
740− error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
420+ if ("onfocusin" === lowerCasedName || "onfocusout" === lowerCasedName)
421+ return (
422+ console.error(
423+ "React uses onFocus and onBlur instead of onFocusIn and onFocusOut. All React events are normalized to bubble, so onFocusIn and onFocusOut are not needed/supported by React."
424+ ),
425+ (warnedProperties[name] = !0)
426+ );
427+ if (
428+ "function" === typeof value &&
429+ (("form" === tagName && "action" === name) ||
430+ ("input" === tagName && "formAction" === name) ||
431+ ("button" === tagName && "formAction" === name))
432+ )
433+ return !0;
434+ if (null != eventRegistry) {
435+ tagName = eventRegistry.possibleRegistrationNames;
436+ if (eventRegistry.registrationNameDependencies.hasOwnProperty(name))
437+ return !0;
438+ eventRegistry = tagName.hasOwnProperty(lowerCasedName)
439+ ? tagName[lowerCasedName]
440+ : null;
441+ if (null != eventRegistry)
442+ return (
443+ console.error(
444+ "Invalid event handler property `%s`. Did you mean `%s`?",
445+ name,
446+ eventRegistry
447+ ),
448+ (warnedProperties[name] = !0)
449+ );
450+ if (EVENT_NAME_REGEX.test(name))
451+ return (
452+ console.error(
453+ "Unknown event handler property `%s`. It will be ignored.",
454+ name
455+ ),
456+ (warnedProperties[name] = !0)
457+ );
458+ } else if (EVENT_NAME_REGEX.test(name))
459+ return (
460+ INVALID_EVENT_NAME_REGEX.test(name) &&
461+ console.error(
462+ "Invalid event handler property `%s`. React events use the camelCase naming convention, for example `onClick`.",
463+ name
464+ ),
465+ (warnedProperties[name] = !0)
466+ );
467+ if (rARIA.test(name) || rARIACamel.test(name)) return !0;
468+ if ("innerhtml" === lowerCasedName)
469+ return (
470+ console.error(
471+ "Directly setting property `innerHTML` is not permitted. For more information, lookup documentation on `dangerouslySetInnerHTML`."
472+ ),
473+ (warnedProperties[name] = !0)
474+ );
475+ if ("aria" === lowerCasedName)
476+ return (
477+ console.error(
478+ "The `aria` attribute is reserved for future use in React. Pass individual `aria-` attributes instead."
479+ ),
480+ (warnedProperties[name] = !0)
481+ );
482+ if (
483+ "is" === lowerCasedName &&
484+ null !== value &&
485+ void 0 !== value &&
486+ "string" !== typeof value
487+ )
488+ return (
489+ console.error(
490+ "Received a `%s` for a string attribute `is`. If this is expected, cast the value to a string.",
491+ typeof value
492+ ),
493+ (warnedProperties[name] = !0)
494+ );
495+ if ("number" === typeof value && isNaN(value))
496+ return (
497+ console.error(
498+ "Received NaN for the `%s` attribute. If this is expected, cast the value to a string.",
499+ name
500+ ),
501+ (warnedProperties[name] = !0)
502+ );
503+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
504+ if (
505+ ((lowerCasedName = possibleStandardNames[lowerCasedName]),
506+ lowerCasedName !== name)
507+ )
508+ return (
509+ console.error(
510+ "Invalid DOM property `%s`. Did you mean `%s`?",
511+ name,
512+ lowerCasedName
513+ ),
514+ (warnedProperties[name] = !0)
515+ );
516+ } else if (name !== lowerCasedName)
517+ return (
518+ console.error(
519+ "React does not recognize the `%s` prop on a DOM element. If you intentionally want it to appear in the DOM as a custom attribute, spell it as lowercase `%s` instead. If you accidentally passed it from a parent component, remove it from the DOM element.",
520+ name,
521+ lowerCasedName
522+ ),
523+ (warnedProperties[name] = !0)
524+ );
525+ switch (name) {
526+ case "dangerouslySetInnerHTML":
527+ case "children":
528+ case "style":
529+ case "suppressContentEditableWarning":
530+ case "suppressHydrationWarning":
531+ case "defaultValue":
532+ case "defaultChecked":
533+ case "innerHTML":
534+ case "ref":
535+ return !0;
536+ case "innerText":
537+ case "textContent":
538+ return !0;
539+ }
540+ switch (typeof value) {
541+ case "boolean":
542+ switch (name) {
543+ case "autoFocus":
544+ case "checked":
545+ case "multiple":
546+ case "muted":
547+ case "selected":
548+ case "contentEditable":
549+ case "spellCheck":
550+ case "draggable":
551+ case "value":
552+ case "autoReverse":
553+ case "externalResourcesRequired":
554+ case "focusable":
555+ case "preserveAlpha":
556+ case "allowFullScreen":
557+ case "async":
558+ case "autoPlay":
559+ case "controls":
560+ case "default":
561+ case "defer":
562+ case "disabled":
563+ case "disablePictureInPicture":
564+ case "disableRemotePlayback":
565+ case "formNoValidate":
566+ case "hidden":
567+ case "loop":
568+ case "noModule":
569+ case "noValidate":
570+ case "open":
571+ case "playsInline":
572+ case "readOnly":
573+ case "required":
574+ case "reversed":
575+ case "scoped":
576+ case "seamless":
577+ case "itemScope":
578+ case "capture":
579+ case "download":
580+ case "inert":
581+ return !0;
582+ default:
583+ lowerCasedName = name.toLowerCase().slice(0, 5);
584+ if ("data-" === lowerCasedName || "aria-" === lowerCasedName)
585+ return !0;
586+ value
587+ ? console.error(
588+ 'Received `%s` for a non-boolean attribute `%s`.\n\nIf you want to write it to the DOM, pass a string instead: %s="%s" or %s={value.toString()}.',
589+ value,
590+ name,
591+ name,
592+ value,
593+ name
594+ )
595+ : console.error(
596+ 'Received `%s` for a non-boolean attribute `%s`.\n\nIf you want to write it to the DOM, pass a string instead: %s="%s" or %s={value.toString()}.\n\nIf you used to conditionally omit it with %s={condition && value}, pass %s={condition ? value : undefined} instead.',
597+ value,
598+ name,
599+ name,
600+ value,
601+ name,
602+ name,
603+ name
604+ );
605+ return (warnedProperties[name] = !0);
606+ }
607+ case "function":
608+ case "symbol":
609+ return (warnedProperties[name] = !0), !1;
610+ case "string":
611+ if ("false" === value || "true" === value) {
612+ switch (name) {
613+ case "checked":
614+ case "selected":
615+ case "multiple":
616+ case "muted":
617+ case "allowFullScreen":
618+ case "async":
619+ case "autoPlay":
620+ case "controls":
621+ case "default":
622+ case "defer":
623+ case "disabled":
624+ case "disablePictureInPicture":
625+ case "disableRemotePlayback":
626+ case "formNoValidate":
627+ case "hidden":
628+ case "loop":
629+ case "noModule":
630+ case "noValidate":
631+ case "open":
632+ case "playsInline":
633+ case "readOnly":
634+ case "required":
635+ case "reversed":
636+ case "scoped":
637+ case "seamless":
638+ case "itemScope":
639+ case "inert":
640+ break;
641+ default:
642+ return !0;
643+ }
644+ console.error(
645+ "Received the string `%s` for the boolean attribute `%s`. %s Did you mean %s={%s}?",
646+ value,
647+ name,
648+ "false" === value
649+ ? "The browser will interpret it as a truthy value."
650+ : 'Although this works, it will not work as expected if you pass the string "false".',
651+ name,
652+ value
653+ );
654+ warnedProperties[name] = !0;
655+ }
741656 }
657+ return !0;
658+ }
659+ function warnUnknownProperties(type, props, eventRegistry) {
660+ var unknownProps = [],
661+ key;
662+ for (key in props)
663+ validateProperty(type, key, props[key], eventRegistry) ||
664+ unknownProps.push(key);
665+ props = unknownProps
666+ .map(function (prop) {
667+ return "`" + prop + "`";
668+ })
669+ .join(", ");
670+ 1 === unknownProps.length
671+ ? console.error(
672+ "Invalid value for prop %s on <%s> tag. Either remove it from the element, or pass a string or number value to keep it in the DOM. For details, see https://react.dev/link/attribute-behavior ",
673+ props,
674+ type
675+ )
676+ : 1 < unknownProps.length &&
677+ console.error(
678+ "Invalid values for props %s on <%s> tag. Either remove them from the element, or pass a string or number value to keep them in the DOM. For details, see https://react.dev/link/attribute-behavior ",
679+ props,
680+ type
681+ );
682+ }
683+ function camelize(string) {
684+ return string.replace(hyphenPattern, function (_, character) {
685+ return character.toUpperCase();
686+ });
742687 }
743− }
744−}
745−
746−// When adding attributes to the HTML or SVG allowed attribute list, be sure to
747−// also add them to this module to ensure casing and incorrect name
748−// warnings.
749−var possibleStandardNames = {
750− // HTML
751− accept: 'accept',
752− acceptcharset: 'acceptCharset',
753− 'accept-charset': 'acceptCharset',
754− accesskey: 'accessKey',
755− action: 'action',
756− allowfullscreen: 'allowFullScreen',
757− alt: 'alt',
758− as: 'as',
759− async: 'async',
760− autocapitalize: 'autoCapitalize',
761− autocomplete: 'autoComplete',
762− autocorrect: 'autoCorrect',
763− autofocus: 'autoFocus',
764− autoplay: 'autoPlay',
765− autosave: 'autoSave',
766− capture: 'capture',
767− cellpadding: 'cellPadding',
768− cellspacing: 'cellSpacing',
769− challenge: 'challenge',
770− charset: 'charSet',
771− checked: 'checked',
772− children: 'children',
773− cite: 'cite',
774− class: 'className',
775− classid: 'classID',
776− classname: 'className',
777− cols: 'cols',
778− colspan: 'colSpan',
779− content: 'content',
780− contenteditable: 'contentEditable',
781− contextmenu: 'contextMenu',
782− controls: 'controls',
783− controlslist: 'controlsList',
784− coords: 'coords',
785− crossorigin: 'crossOrigin',
786− dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
787− data: 'data',
788− datetime: 'dateTime',
789− default: 'default',
790− defaultchecked: 'defaultChecked',
791− defaultvalue: 'defaultValue',
792− defer: 'defer',
793− dir: 'dir',
794− disabled: 'disabled',
795− disablepictureinpicture: 'disablePictureInPicture',
796− disableremoteplayback: 'disableRemotePlayback',
797− download: 'download',
798− draggable: 'draggable',
799− enctype: 'encType',
800− enterkeyhint: 'enterKeyHint',
801− for: 'htmlFor',
802− form: 'form',
803− formmethod: 'formMethod',
804− formaction: 'formAction',
805− formenctype: 'formEncType',
806− formnovalidate: 'formNoValidate',
807− formtarget: 'formTarget',
808− frameborder: 'frameBorder',
809− headers: 'headers',
810− height: 'height',
811− hidden: 'hidden',
812− high: 'high',
813− href: 'href',
814− hreflang: 'hrefLang',
815− htmlfor: 'htmlFor',
816− httpequiv: 'httpEquiv',
817− 'http-equiv': 'httpEquiv',
818− icon: 'icon',
819− id: 'id',
820− imagesizes: 'imageSizes',
821− imagesrcset: 'imageSrcSet',
822− innerhtml: 'innerHTML',
823− inputmode: 'inputMode',
824− integrity: 'integrity',
825− is: 'is',
826− itemid: 'itemID',
827− itemprop: 'itemProp',
828− itemref: 'itemRef',
829− itemscope: 'itemScope',
830− itemtype: 'itemType',
831− keyparams: 'keyParams',
832− keytype: 'keyType',
833− kind: 'kind',
834− label: 'label',
835− lang: 'lang',
836− list: 'list',
837− loop: 'loop',
838− low: 'low',
839− manifest: 'manifest',
840− marginwidth: 'marginWidth',
841− marginheight: 'marginHeight',
842− max: 'max',
843− maxlength: 'maxLength',
844− media: 'media',
845− mediagroup: 'mediaGroup',
846− method: 'method',
847− min: 'min',
848− minlength: 'minLength',
849− multiple: 'multiple',
850− muted: 'muted',
851− name: 'name',
852− nomodule: 'noModule',
853− nonce: 'nonce',
854− novalidate: 'noValidate',
855− open: 'open',
856− optimum: 'optimum',
857− pattern: 'pattern',
858− placeholder: 'placeholder',
859− playsinline: 'playsInline',
860− poster: 'poster',
861− preload: 'preload',
862− profile: 'profile',
863− radiogroup: 'radioGroup',
864− readonly: 'readOnly',
865− referrerpolicy: 'referrerPolicy',
866− rel: 'rel',
867− required: 'required',
868− reversed: 'reversed',
869− role: 'role',
870− rows: 'rows',
871− rowspan: 'rowSpan',
872− sandbox: 'sandbox',
873− scope: 'scope',
874− scoped: 'scoped',
875− scrolling: 'scrolling',
876− seamless: 'seamless',
877− selected: 'selected',
878− shape: 'shape',
879− size: 'size',
880− sizes: 'sizes',
881− span: 'span',
882− spellcheck: 'spellCheck',
883− src: 'src',
884− srcdoc: 'srcDoc',
885− srclang: 'srcLang',
886− srcset: 'srcSet',
887− start: 'start',
888− step: 'step',
889− style: 'style',
890− summary: 'summary',
891− tabindex: 'tabIndex',
892− target: 'target',
893− title: 'title',
894− type: 'type',
895− usemap: 'useMap',
896− value: 'value',
897− width: 'width',
898− wmode: 'wmode',
899− wrap: 'wrap',
900− // SVG
901− about: 'about',
902− accentheight: 'accentHeight',
903− 'accent-height': 'accentHeight',
904− accumulate: 'accumulate',
905− additive: 'additive',
906− alignmentbaseline: 'alignmentBaseline',
907− 'alignment-baseline': 'alignmentBaseline',
908− allowreorder: 'allowReorder',
909− alphabetic: 'alphabetic',
910− amplitude: 'amplitude',
911− arabicform: 'arabicForm',
912− 'arabic-form': 'arabicForm',
913− ascent: 'ascent',
914− attributename: 'attributeName',
915− attributetype: 'attributeType',
916− autoreverse: 'autoReverse',
917− azimuth: 'azimuth',
918− basefrequency: 'baseFrequency',
919− baselineshift: 'baselineShift',
920− 'baseline-shift': 'baselineShift',
921− baseprofile: 'baseProfile',
922− bbox: 'bbox',
923− begin: 'begin',
924− bias: 'bias',
925− by: 'by',
926− calcmode: 'calcMode',
927− capheight: 'capHeight',
928− 'cap-height': 'capHeight',
929− clip: 'clip',
930− clippath: 'clipPath',
931− 'clip-path': 'clipPath',
932− clippathunits: 'clipPathUnits',
933− cliprule: 'clipRule',
934− 'clip-rule': 'clipRule',
935− color: 'color',
936− colorinterpolation: 'colorInterpolation',
937− 'color-interpolation': 'colorInterpolation',
938− colorinterpolationfilters: 'colorInterpolationFilters',
939− 'color-interpolation-filters': 'colorInterpolationFilters',
940− colorprofile: 'colorProfile',
941− 'color-profile': 'colorProfile',
942− colorrendering: 'colorRendering',
943− 'color-rendering': 'colorRendering',
944− contentscripttype: 'contentScriptType',
945− contentstyletype: 'contentStyleType',
946− cursor: 'cursor',
947− cx: 'cx',
948− cy: 'cy',
949− d: 'd',
950− datatype: 'datatype',
951− decelerate: 'decelerate',
952− descent: 'descent',
953− diffuseconstant: 'diffuseConstant',
954− direction: 'direction',
955− display: 'display',
956− divisor: 'divisor',
957− dominantbaseline: 'dominantBaseline',
958− 'dominant-baseline': 'dominantBaseline',
959− dur: 'dur',
960− dx: 'dx',
961− dy: 'dy',
962− edgemode: 'edgeMode',
963− elevation: 'elevation',
964− enablebackground: 'enableBackground',
965− 'enable-background': 'enableBackground',
966− end: 'end',
967− exponent: 'exponent',
968− externalresourcesrequired: 'externalResourcesRequired',
969− fill: 'fill',
970− fillopacity: 'fillOpacity',
971− 'fill-opacity': 'fillOpacity',
972− fillrule: 'fillRule',
973− 'fill-rule': 'fillRule',
974− filter: 'filter',
975− filterres: 'filterRes',
976− filterunits: 'filterUnits',
977− floodopacity: 'floodOpacity',
978− 'flood-opacity': 'floodOpacity',
979− floodcolor: 'floodColor',
980− 'flood-color': 'floodColor',
981− focusable: 'focusable',
982− fontfamily: 'fontFamily',
983− 'font-family': 'fontFamily',
984− fontsize: 'fontSize',
985− 'font-size': 'fontSize',
986− fontsizeadjust: 'fontSizeAdjust',
987− 'font-size-adjust': 'fontSizeAdjust',
988− fontstretch: 'fontStretch',
989− 'font-stretch': 'fontStretch',
990− fontstyle: 'fontStyle',
991− 'font-style': 'fontStyle',
992− fontvariant: 'fontVariant',
993− 'font-variant': 'fontVariant',
994− fontweight: 'fontWeight',
995− 'font-weight': 'fontWeight',
996− format: 'format',
997− from: 'from',
998− fx: 'fx',
999− fy: 'fy',
1000− g1: 'g1',
1001− g2: 'g2',
1002− glyphname: 'glyphName',
1003− 'glyph-name': 'glyphName',
1004− glyphorientationhorizontal: 'glyphOrientationHorizontal',
1005− 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
1006− glyphorientationvertical: 'glyphOrientationVertical',
1007− 'glyph-orientation-vertical': 'glyphOrientationVertical',
1008− glyphref: 'glyphRef',
1009− gradienttransform: 'gradientTransform',
1010− gradientunits: 'gradientUnits',
1011− hanging: 'hanging',
1012− horizadvx: 'horizAdvX',
1013− 'horiz-adv-x': 'horizAdvX',
1014− horizoriginx: 'horizOriginX',
1015− 'horiz-origin-x': 'horizOriginX',
1016− ideographic: 'ideographic',
1017− imagerendering: 'imageRendering',
1018− 'image-rendering': 'imageRendering',
1019− in2: 'in2',
1020− in: 'in',
1021− inlist: 'inlist',
1022− intercept: 'intercept',
1023− k1: 'k1',
1024− k2: 'k2',
1025− k3: 'k3',
1026− k4: 'k4',
1027− k: 'k',
1028− kernelmatrix: 'kernelMatrix',
1029− kernelunitlength: 'kernelUnitLength',
1030− kerning: 'kerning',
1031− keypoints: 'keyPoints',
1032− keysplines: 'keySplines',
1033− keytimes: 'keyTimes',
1034− lengthadjust: 'lengthAdjust',
1035− letterspacing: 'letterSpacing',
1036− 'letter-spacing': 'letterSpacing',
1037− lightingcolor: 'lightingColor',
1038− 'lighting-color': 'lightingColor',
1039− limitingconeangle: 'limitingConeAngle',
1040− local: 'local',
1041− markerend: 'markerEnd',
1042− 'marker-end': 'markerEnd',
1043− markerheight: 'markerHeight',
1044− markermid: 'markerMid',
1045− 'marker-mid': 'markerMid',
1046− markerstart: 'markerStart',
1047− 'marker-start': 'markerStart',
1048− markerunits: 'markerUnits',
1049− markerwidth: 'markerWidth',
1050− mask: 'mask',
1051− maskcontentunits: 'maskContentUnits',
1052− maskunits: 'maskUnits',
1053− mathematical: 'mathematical',
1054− mode: 'mode',
1055− numoctaves: 'numOctaves',
1056− offset: 'offset',
1057− opacity: 'opacity',
1058− operator: 'operator',
1059− order: 'order',
1060− orient: 'orient',
1061− orientation: 'orientation',
1062− origin: 'origin',
1063− overflow: 'overflow',
1064− overlineposition: 'overlinePosition',
1065− 'overline-position': 'overlinePosition',
1066− overlinethickness: 'overlineThickness',
1067− 'overline-thickness': 'overlineThickness',
1068− paintorder: 'paintOrder',
1069− 'paint-order': 'paintOrder',
1070− panose1: 'panose1',
1071− 'panose-1': 'panose1',
1072− pathlength: 'pathLength',
1073− patterncontentunits: 'patternContentUnits',
1074− patterntransform: 'patternTransform',
1075− patternunits: 'patternUnits',
1076− pointerevents: 'pointerEvents',
1077− 'pointer-events': 'pointerEvents',
1078− points: 'points',
1079− pointsatx: 'pointsAtX',
1080− pointsaty: 'pointsAtY',
1081− pointsatz: 'pointsAtZ',
1082− prefix: 'prefix',
1083− preservealpha: 'preserveAlpha',
1084− preserveaspectratio: 'preserveAspectRatio',
1085− primitiveunits: 'primitiveUnits',
1086− property: 'property',
1087− r: 'r',
1088− radius: 'radius',
1089− refx: 'refX',
1090− refy: 'refY',
1091− renderingintent: 'renderingIntent',
1092− 'rendering-intent': 'renderingIntent',
1093− repeatcount: 'repeatCount',
1094− repeatdur: 'repeatDur',
1095− requiredextensions: 'requiredExtensions',
1096− requiredfeatures: 'requiredFeatures',
1097− resource: 'resource',
1098− restart: 'restart',
1099− result: 'result',
1100− results: 'results',
1101− rotate: 'rotate',
1102− rx: 'rx',
1103− ry: 'ry',
1104− scale: 'scale',
1105− security: 'security',
1106− seed: 'seed',
1107− shaperendering: 'shapeRendering',
1108− 'shape-rendering': 'shapeRendering',
1109− slope: 'slope',
1110− spacing: 'spacing',
1111− specularconstant: 'specularConstant',
1112− specularexponent: 'specularExponent',
1113− speed: 'speed',
1114− spreadmethod: 'spreadMethod',
1115− startoffset: 'startOffset',
1116− stddeviation: 'stdDeviation',
1117− stemh: 'stemh',
1118− stemv: 'stemv',
1119− stitchtiles: 'stitchTiles',
1120− stopcolor: 'stopColor',
1121− 'stop-color': 'stopColor',
1122− stopopacity: 'stopOpacity',
1123− 'stop-opacity': 'stopOpacity',
1124− strikethroughposition: 'strikethroughPosition',
1125− 'strikethrough-position': 'strikethroughPosition',
1126− strikethroughthickness: 'strikethroughThickness',
1127− 'strikethrough-thickness': 'strikethroughThickness',
1128− string: 'string',
1129− stroke: 'stroke',
1130− strokedasharray: 'strokeDasharray',
1131− 'stroke-dasharray': 'strokeDasharray',
1132− strokedashoffset: 'strokeDashoffset',
1133− 'stroke-dashoffset': 'strokeDashoffset',
1134− strokelinecap: 'strokeLinecap',
1135− 'stroke-linecap': 'strokeLinecap',
1136− strokelinejoin: 'strokeLinejoin',
1137− 'stroke-linejoin': 'strokeLinejoin',
1138− strokemiterlimit: 'strokeMiterlimit',
1139− 'stroke-miterlimit': 'strokeMiterlimit',
1140− strokewidth: 'strokeWidth',
1141− 'stroke-width': 'strokeWidth',
1142− strokeopacity: 'strokeOpacity',
1143− 'stroke-opacity': 'strokeOpacity',
1144− suppresscontenteditablewarning: 'suppressContentEditableWarning',
1145− suppresshydrationwarning: 'suppressHydrationWarning',
1146− surfacescale: 'surfaceScale',
1147− systemlanguage: 'systemLanguage',
1148− tablevalues: 'tableValues',
1149− targetx: 'targetX',
1150− targety: 'targetY',
1151− textanchor: 'textAnchor',
1152− 'text-anchor': 'textAnchor',
1153− textdecoration: 'textDecoration',
1154− 'text-decoration': 'textDecoration',
1155− textlength: 'textLength',
1156− textrendering: 'textRendering',
1157− 'text-rendering': 'textRendering',
1158− to: 'to',
1159− transform: 'transform',
1160− typeof: 'typeof',
1161− u1: 'u1',
1162− u2: 'u2',
1163− underlineposition: 'underlinePosition',
1164− 'underline-position': 'underlinePosition',
1165− underlinethickness: 'underlineThickness',
1166− 'underline-thickness': 'underlineThickness',
1167− unicode: 'unicode',
1168− unicodebidi: 'unicodeBidi',
1169− 'unicode-bidi': 'unicodeBidi',
1170− unicoderange: 'unicodeRange',
1171− 'unicode-range': 'unicodeRange',
1172− unitsperem: 'unitsPerEm',
1173− 'units-per-em': 'unitsPerEm',
1174− unselectable: 'unselectable',
1175− valphabetic: 'vAlphabetic',
1176− 'v-alphabetic': 'vAlphabetic',
1177− values: 'values',
1178− vectoreffect: 'vectorEffect',
1179− 'vector-effect': 'vectorEffect',
1180− version: 'version',
1181− vertadvy: 'vertAdvY',
1182− 'vert-adv-y': 'vertAdvY',
1183− vertoriginx: 'vertOriginX',
1184− 'vert-origin-x': 'vertOriginX',
1185− vertoriginy: 'vertOriginY',
1186− 'vert-origin-y': 'vertOriginY',
1187− vhanging: 'vHanging',
1188− 'v-hanging': 'vHanging',
1189− videographic: 'vIdeographic',
1190− 'v-ideographic': 'vIdeographic',
1191− viewbox: 'viewBox',
1192− viewtarget: 'viewTarget',
1193− visibility: 'visibility',
1194− vmathematical: 'vMathematical',
1195− 'v-mathematical': 'vMathematical',
1196− vocab: 'vocab',
1197− widths: 'widths',
1198− wordspacing: 'wordSpacing',
1199− 'word-spacing': 'wordSpacing',
1200− writingmode: 'writingMode',
1201− 'writing-mode': 'writingMode',
1202− x1: 'x1',
1203− x2: 'x2',
1204− x: 'x',
1205− xchannelselector: 'xChannelSelector',
1206− xheight: 'xHeight',
1207− 'x-height': 'xHeight',
1208− xlinkactuate: 'xlinkActuate',
1209− 'xlink:actuate': 'xlinkActuate',
1210− xlinkarcrole: 'xlinkArcrole',
1211− 'xlink:arcrole': 'xlinkArcrole',
1212− xlinkhref: 'xlinkHref',
1213− 'xlink:href': 'xlinkHref',
1214− xlinkrole: 'xlinkRole',
1215− 'xlink:role': 'xlinkRole',
1216− xlinkshow: 'xlinkShow',
1217− 'xlink:show': 'xlinkShow',
1218− xlinktitle: 'xlinkTitle',
1219− 'xlink:title': 'xlinkTitle',
1220− xlinktype: 'xlinkType',
1221− 'xlink:type': 'xlinkType',
1222− xmlbase: 'xmlBase',
1223− 'xml:base': 'xmlBase',
1224− xmllang: 'xmlLang',
1225− 'xml:lang': 'xmlLang',
1226− xmlns: 'xmlns',
1227− 'xml:space': 'xmlSpace',
1228− xmlnsxlink: 'xmlnsXlink',
1229− 'xmlns:xlink': 'xmlnsXlink',
1230− xmlspace: 'xmlSpace',
1231− y1: 'y1',
1232− y2: 'y2',
1233− y: 'y',
1234− ychannelselector: 'yChannelSelector',
1235− z: 'z',
1236− zoomandpan: 'zoomAndPan'
1237−};
1238−
1239−var validateProperty$1 = function () {};
1240−
1241−{
1242− var warnedProperties$1 = {};
1243− var EVENT_NAME_REGEX = /^on./;
1244− var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
1245− var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
1246− var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
1247−
1248− validateProperty$1 = function (tagName, name, value, eventRegistry) {
1249− if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
1250− return true;
1251− }
1252−
1253− var lowerCasedName = name.toLowerCase();
1254−
1255− if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
1256− error('React uses onFocus and onBlur instead of onFocusIn and onFocusOut. ' + 'All React events are normalized to bubble, so onFocusIn and onFocusOut ' + 'are not needed/supported by React.');
1257−
1258− warnedProperties$1[name] = true;
1259− return true;
1260− } // We can't rely on the event system being injected on the server.
1261−
1262−
1263− if (eventRegistry != null) {
1264− var registrationNameDependencies = eventRegistry.registrationNameDependencies,
1265− possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
1266−
1267− if (registrationNameDependencies.hasOwnProperty(name)) {
1268− return true;
1269− }
1270−
1271− var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
1272−
1273− if (registrationName != null) {
1274− error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
1275−
1276− warnedProperties$1[name] = true;
1277− return true;
1278− }
1279−
1280− if (EVENT_NAME_REGEX.test(name)) {
1281− error('Unknown event handler property `%s`. It will be ignored.', name);
1282−
1283− warnedProperties$1[name] = true;
1284− return true;
1285− }
1286− } else if (EVENT_NAME_REGEX.test(name)) {
1287− // If no event plugins have been injected, we are in a server environment.
1288− // So we can't tell if the event name is correct for sure, but we can filter
1289− // out known bad ones like `onclick`. We can't suggest a specific replacement though.
1290− if (INVALID_EVENT_NAME_REGEX.test(name)) {
1291− error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
688+ function escapeTextForBrowser(text) {
689+ if (
690+ "boolean" === typeof text ||
691+ "number" === typeof text ||
692+ "bigint" === typeof text
693+ )
694+ return "" + text;
695+ checkHtmlStringCoercion(text);
696+ text = "" + text;
697+ var match = matchHtmlRegExp.exec(text);
698+ if (match) {
699+ var html = "",
700+ index,
701+ lastIndex = 0;
702+ for (index = match.index; index < text.length; index++) {
703+ switch (text.charCodeAt(index)) {
704+ case 34:
705+ match = """;
706+ break;
707+ case 38:
708+ match = "&";
709+ break;
710+ case 39:
711+ match = "'";
712+ break;
713+ case 60:
714+ match = "<";
715+ break;
716+ case 62:
717+ match = ">";
718+ break;
719+ default:
720+ continue;
721+ }
722+ lastIndex !== index && (html += text.slice(lastIndex, index));
723+ lastIndex = index + 1;
724+ html += match;
725+ }
726+ text = lastIndex !== index ? html + text.slice(lastIndex, index) : html;
1292727 }
1293−
1294− warnedProperties$1[name] = true;
1295− return true;
1296− } // Let the ARIA attribute hook validate ARIA attributes
1297−
1298−
1299− if (rARIA$1.test(name) || rARIACamel$1.test(name)) {
1300− return true;
1301− }
1302−
1303− if (lowerCasedName === 'innerhtml') {
1304− error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
1305−
1306− warnedProperties$1[name] = true;
1307− return true;
1308− }
1309−
1310− if (lowerCasedName === 'aria') {
1311− error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
1312−
1313− warnedProperties$1[name] = true;
1314− return true;
1315− }
1316−
1317− if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
1318− error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
1319−
1320− warnedProperties$1[name] = true;
1321− return true;
728+ return text;
1322729 }
1323−
1324− if (typeof value === 'number' && isNaN(value)) {
1325− error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
1326−
1327− warnedProperties$1[name] = true;
1328− return true;
730+ function sanitizeURL(url) {
731+ return isJavaScriptProtocol.test("" + url)
732+ ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')"
733+ : url;
1329734 }
1330−
1331− var propertyInfo = getPropertyInfo(name);
1332− var isReserved = propertyInfo !== null && propertyInfo.type === RESERVED; // Known attributes should match the casing specified in the property config.
1333−
1334− if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
1335− var standardName = possibleStandardNames[lowerCasedName];
1336−
1337− if (standardName !== name) {
1338− error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
1339−
1340− warnedProperties$1[name] = true;
1341− return true;
1342− }
1343− } else if (!isReserved && name !== lowerCasedName) {
1344− // Unknown attributes should have lowercase casing since that's how they
1345− // will be cased anyway with server rendering.
1346− error('React does not recognize the `%s` prop on a DOM element. If you ' + 'intentionally want it to appear in the DOM as a custom ' + 'attribute, spell it as lowercase `%s` instead. ' + 'If you accidentally passed it from a parent component, remove ' + 'it from the DOM element.', name, lowerCasedName);
1347−
1348− warnedProperties$1[name] = true;
1349− return true;
735+ function escapeEntireInlineScriptContent(scriptText) {
736+ checkHtmlStringCoercion(scriptText);
737+ return ("" + scriptText).replace(scriptRegex, scriptReplacer);
1350738 }
1351−
1352− if (typeof value === 'boolean' && shouldRemoveAttributeWithWarning(name, value, propertyInfo, false)) {
1353− if (value) {
1354− error('Received `%s` for a non-boolean attribute `%s`.\n\n' + 'If you want to write it to the DOM, pass a string instead: ' + '%s="%s" or %s={value.toString()}.', value, name, name, value, name);
1355− } else {
1356− error('Received `%s` for a non-boolean attribute `%s`.\n\n' + 'If you want to write it to the DOM, pass a string instead: ' + '%s="%s" or %s={value.toString()}.\n\n' + 'If you used to conditionally omit it with %s={condition && value}, ' + 'pass %s={condition ? value : undefined} instead.', value, name, name, value, name, name, name);
739+ function createResumableState(
740+ identifierPrefix,
741+ externalRuntimeConfig,
742+ bootstrapScriptContent,
743+ bootstrapScripts,
744+ bootstrapModules
745+ ) {
746+ return {
747+ idPrefix: void 0 === identifierPrefix ? "" : identifierPrefix,
748+ nextFormID: 0,
749+ streamingFormat: 0,
750+ bootstrapScriptContent: bootstrapScriptContent,
751+ bootstrapScripts: bootstrapScripts,
752+ bootstrapModules: bootstrapModules,
753+ instructions: NothingSent,
754+ hasBody: !1,
755+ hasHtml: !1,
756+ unknownResources: {},
757+ dnsResources: {},
758+ connectResources: { default: {}, anonymous: {}, credentials: {} },
759+ imageResources: {},
760+ styleResources: {},
761+ scriptResources: {},
762+ moduleUnknownResources: {},
763+ moduleScriptResources: {}
764+ };
765+ }
766+ function createFormatContext(
767+ insertionMode,
768+ selectedValue,
769+ tagScope,
770+ viewTransition
771+ ) {
772+ return {
773+ insertionMode: insertionMode,
774+ selectedValue: selectedValue,
775+ tagScope: tagScope,
776+ viewTransition: viewTransition
777+ };
778+ }
779+ function getChildFormatContext(parentContext, type, props) {
780+ var subtreeScope = parentContext.tagScope & -25;
781+ switch (type) {
782+ case "noscript":
783+ return createFormatContext(HTML_MODE, null, subtreeScope | 1, null);
784+ case "select":
785+ return createFormatContext(
786+ HTML_MODE,
787+ null != props.value ? props.value : props.defaultValue,
788+ subtreeScope,
789+ null
790+ );
791+ case "svg":
792+ return createFormatContext(SVG_MODE, null, subtreeScope, null);
793+ case "picture":
794+ return createFormatContext(HTML_MODE, null, subtreeScope | 2, null);
795+ case "math":
796+ return createFormatContext(MATHML_MODE, null, subtreeScope, null);
797+ case "foreignObject":
798+ return createFormatContext(HTML_MODE, null, subtreeScope, null);
799+ case "table":
800+ return createFormatContext(HTML_TABLE_MODE, null, subtreeScope, null);
801+ case "thead":
802+ case "tbody":
803+ case "tfoot":
804+ return createFormatContext(
805+ HTML_TABLE_BODY_MODE,
806+ null,
807+ subtreeScope,
808+ null
809+ );
810+ case "colgroup":
811+ return createFormatContext(
812+ HTML_COLGROUP_MODE,
813+ null,
814+ subtreeScope,
815+ null
816+ );
817+ case "tr":
818+ return createFormatContext(
819+ HTML_TABLE_ROW_MODE,
820+ null,
821+ subtreeScope,
822+ null
823+ );
824+ case "head":
825+ if (parentContext.insertionMode < HTML_MODE)
826+ return createFormatContext(
827+ HTML_HEAD_MODE,
828+ null,
829+ subtreeScope,
830+ null
831+ );
832+ break;
833+ case "html":
834+ if (parentContext.insertionMode === ROOT_HTML_MODE)
835+ return createFormatContext(
836+ HTML_HTML_MODE,
837+ null,
838+ subtreeScope,
839+ null
840+ );
841+ }
842+ return parentContext.insertionMode >= HTML_TABLE_MODE ||
843+ parentContext.insertionMode < HTML_MODE
844+ ? createFormatContext(HTML_MODE, null, subtreeScope, null)
845+ : parentContext.tagScope !== subtreeScope
846+ ? createFormatContext(
847+ parentContext.insertionMode,
848+ parentContext.selectedValue,
849+ subtreeScope,
850+ null
851+ )
852+ : parentContext;
853+ }
854+ function getSuspenseViewTransition(parentViewTransition) {
855+ return null === parentViewTransition
856+ ? null
857+ : {
858+ update: parentViewTransition.update,
859+ enter: "none",
860+ exit: "none",
861+ share: parentViewTransition.update,
862+ name: parentViewTransition.autoName,
863+ autoName: parentViewTransition.autoName,
864+ nameIdx: 0
865+ };
866+ }
867+ function getSuspenseFallbackFormatContext(resumableState, parentContext) {
868+ parentContext.tagScope & 32 && (resumableState.instructions |= 128);
869+ return createFormatContext(
870+ parentContext.insertionMode,
871+ parentContext.selectedValue,
872+ parentContext.tagScope | 12,
873+ getSuspenseViewTransition(parentContext.viewTransition)
874+ );
875+ }
876+ function getSuspenseContentFormatContext(resumableState, parentContext) {
877+ resumableState = getSuspenseViewTransition(parentContext.viewTransition);
878+ var subtreeScope = parentContext.tagScope | 16;
879+ null !== resumableState &&
880+ "none" !== resumableState.share &&
881+ (subtreeScope |= 64);
882+ return createFormatContext(
883+ parentContext.insertionMode,
884+ parentContext.selectedValue,
885+ subtreeScope,
886+ resumableState
887+ );
888+ }
889+ function pushStyleAttribute(target, style) {
890+ if ("object" !== typeof style)
891+ throw Error(
892+ "The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX."
893+ );
894+ var isFirst = !0,
895+ styleName;
896+ for (styleName in style)
897+ if (hasOwnProperty.call(style, styleName)) {
898+ var styleValue = style[styleName];
899+ if (
900+ null != styleValue &&
901+ "boolean" !== typeof styleValue &&
902+ "" !== styleValue
903+ ) {
904+ if (0 === styleName.indexOf("--")) {
905+ var nameChunk = escapeTextForBrowser(styleName);
906+ checkCSSPropertyStringCoercion(styleValue, styleName);
907+ styleValue = escapeTextForBrowser(("" + styleValue).trim());
908+ } else {
909+ nameChunk = styleName;
910+ var value = styleValue;
911+ if (-1 < nameChunk.indexOf("-")) {
912+ var name = nameChunk;
913+ (warnedStyleNames.hasOwnProperty(name) &&
914+ warnedStyleNames[name]) ||
915+ ((warnedStyleNames[name] = !0),
916+ console.error(
917+ "Unsupported style property %s. Did you mean %s?",
918+ name,
919+ camelize(name.replace(msPattern$1, "ms-"))
920+ ));
921+ } else if (badVendoredStyleNamePattern.test(nameChunk))
922+ (name = nameChunk),
923+ (warnedStyleNames.hasOwnProperty(name) &&
924+ warnedStyleNames[name]) ||
925+ ((warnedStyleNames[name] = !0),
926+ console.error(
927+ "Unsupported vendor-prefixed style property %s. Did you mean %s?",
928+ name,
929+ name.charAt(0).toUpperCase() + name.slice(1)
930+ ));
931+ else if (badStyleValueWithSemicolonPattern.test(value)) {
932+ name = nameChunk;
933+ var value$jscomp$0 = value;
934+ (warnedStyleValues.hasOwnProperty(value$jscomp$0) &&
935+ warnedStyleValues[value$jscomp$0]) ||
936+ ((warnedStyleValues[value$jscomp$0] = !0),
937+ console.error(
938+ 'Style property values shouldn\'t contain a semicolon. Try "%s: %s" instead.',
939+ name,
940+ value$jscomp$0.replace(
941+ badStyleValueWithSemicolonPattern,
942+ ""
943+ )
944+ ));
945+ }
946+ "number" === typeof value &&
947+ (isNaN(value)
948+ ? warnedForNaNValue ||
949+ ((warnedForNaNValue = !0),
950+ console.error(
951+ "`NaN` is an invalid value for the `%s` css style property.",
952+ nameChunk
953+ ))
954+ : isFinite(value) ||
955+ warnedForInfinityValue ||
956+ ((warnedForInfinityValue = !0),
957+ console.error(
958+ "`Infinity` is an invalid value for the `%s` css style property.",
959+ nameChunk
960+ )));
961+ nameChunk = styleName;
962+ value = styleNameCache.get(nameChunk);
963+ void 0 !== value
964+ ? (nameChunk = value)
965+ : ((value = escapeTextForBrowser(
966+ nameChunk
967+ .replace(uppercasePattern, "-$1")
968+ .toLowerCase()
969+ .replace(msPattern, "-ms-")
970+ )),
971+ styleNameCache.set(nameChunk, value),
972+ (nameChunk = value));
973+ "number" === typeof styleValue
974+ ? (styleValue =
975+ 0 === styleValue || unitlessNumbers.has(styleName)
976+ ? "" + styleValue
977+ : styleValue + "px")
978+ : (checkCSSPropertyStringCoercion(styleValue, styleName),
979+ (styleValue = escapeTextForBrowser(
980+ ("" + styleValue).trim()
981+ )));
982+ }
983+ isFirst
984+ ? ((isFirst = !1),
985+ target.push(
986+ styleAttributeStart,
987+ nameChunk,
988+ styleAssign,
989+ styleValue
990+ ))
991+ : target.push(styleSeparator, nameChunk, styleAssign, styleValue);
992+ }
993+ }
994+ isFirst || target.push(attributeEnd);
995+ }
996+ function pushBooleanAttribute(target, name, value) {
997+ value &&
998+ "function" !== typeof value &&
999+ "symbol" !== typeof value &&
1000+ target.push(attributeSeparator, name, attributeEmptyString);
1001+ }
1002+ function pushStringAttribute(target, name, value) {
1003+ "function" !== typeof value &&
1004+ "symbol" !== typeof value &&
1005+ "boolean" !== typeof value &&
1006+ target.push(
1007+ attributeSeparator,
1008+ name,
1009+ attributeAssign,
1010+ escapeTextForBrowser(value),
1011+ attributeEnd
1012+ );
1013+ }
1014+ function pushAdditionalFormField(value, key) {
1015+ this.push('<input type="hidden"');
1016+ validateAdditionalFormField(value);
1017+ pushStringAttribute(this, "name", key);
1018+ pushStringAttribute(this, "value", value);
1019+ this.push(endOfStartTagSelfClosing);
1020+ }
1021+ function validateAdditionalFormField(value) {
1022+ if ("string" !== typeof value)
1023+ throw Error(
1024+ "File/Blob fields are not yet supported in progressive forms. Will fallback to client hydration."
1025+ );
1026+ }
1027+ function getCustomFormFields(resumableState, formAction) {
1028+ if ("function" === typeof formAction.$$FORM_ACTION) {
1029+ var id = resumableState.nextFormID++;
1030+ resumableState = resumableState.idPrefix + id;
1031+ try {
1032+ var customFields = formAction.$$FORM_ACTION(resumableState);
1033+ if (customFields) {
1034+ var formData = customFields.data;
1035+ null != formData && formData.forEach(validateAdditionalFormField);
1036+ }
1037+ return customFields;
1038+ } catch (x) {
1039+ if (
1040+ "object" === typeof x &&
1041+ null !== x &&
1042+ "function" === typeof x.then
1043+ )
1044+ throw x;
1045+ console.error(
1046+ "Failed to serialize an action for progressive enhancement:\n%s",
1047+ x
1048+ );
1049+ }
13571050 }
1358−
1359− warnedProperties$1[name] = true;
1360− return true;
1361− } // Now that we've validated casing, do not validate
1362− // data types for reserved props
1363−
1364−
1365− if (isReserved) {
1366− return true;
1367− } // Warn when a known attribute is a bad type
1368−
1369−
1370− if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, false)) {
1371− warnedProperties$1[name] = true;
1372− return false;
1373− } // Warn when passing the strings 'false' or 'true' into a boolean prop
1374−
1375−
1376− if ((value === 'false' || value === 'true') && propertyInfo !== null && propertyInfo.type === BOOLEAN) {
1377− error('Received the string `%s` for the boolean attribute `%s`. ' + '%s ' + 'Did you mean %s={%s}?', value, name, value === 'false' ? 'The browser will interpret it as a truthy value.' : 'Although this works, it will not work as expected if you pass the string "false".', name, value);
1378−
1379− warnedProperties$1[name] = true;
1380− return true;
1381− }
1382−
1383− return true;
1384− };
1385−}
1386−
1387−var warnUnknownProperties = function (type, props, eventRegistry) {
1388− {
1389− var unknownProps = [];
1390−
1391− for (var key in props) {
1392− var isValid = validateProperty$1(type, key, props[key], eventRegistry);
1393−
1394− if (!isValid) {
1395− unknownProps.push(key);
1051+ return null;
1052+ }
1053+ function pushFormActionAttribute(
1054+ target,
1055+ resumableState,
1056+ renderState,
1057+ formAction,
1058+ formEncType,
1059+ formMethod,
1060+ formTarget,
1061+ name
1062+ ) {
1063+ var formData = null;
1064+ if ("function" === typeof formAction) {
1065+ null === name ||
1066+ didWarnFormActionName ||
1067+ ((didWarnFormActionName = !0),
1068+ console.error(
1069+ 'Cannot specify a "name" prop for a button that specifies a function as a formAction. React needs it to encode which action should be invoked. It will get overridden.'
1070+ ));
1071+ (null === formEncType && null === formMethod) ||
1072+ didWarnFormActionMethod ||
1073+ ((didWarnFormActionMethod = !0),
1074+ console.error(
1075+ "Cannot specify a formEncType or formMethod for a button that specifies a function as a formAction. React provides those automatically. They will get overridden."
1076+ ));
1077+ null === formTarget ||
1078+ didWarnFormActionTarget ||
1079+ ((didWarnFormActionTarget = !0),
1080+ console.error(
1081+ "Cannot specify a formTarget for a button that specifies a function as a formAction. The function will always be executed in the same window."
1082+ ));
1083+ var customFields = getCustomFormFields(resumableState, formAction);
1084+ null !== customFields
1085+ ? ((name = customFields.name),
1086+ (formAction = customFields.action || ""),
1087+ (formEncType = customFields.encType),
1088+ (formMethod = customFields.method),
1089+ (formTarget = customFields.target),
1090+ (formData = customFields.data))
1091+ : (target.push(
1092+ attributeSeparator,
1093+ "formAction",
1094+ attributeAssign,
1095+ actionJavaScriptURL,
1096+ attributeEnd
1097+ ),
1098+ (formTarget = formMethod = formEncType = formAction = name = null),
1099+ injectFormReplayingRuntime(resumableState, renderState));
1100+ }
1101+ null != name && pushAttribute(target, "name", name);
1102+ null != formAction && pushAttribute(target, "formAction", formAction);
1103+ null != formEncType && pushAttribute(target, "formEncType", formEncType);
1104+ null != formMethod && pushAttribute(target, "formMethod", formMethod);
1105+ null != formTarget && pushAttribute(target, "formTarget", formTarget);
1106+ return formData;
1107+ }
1108+ function pushAttribute(target, name, value) {
1109+ switch (name) {
1110+ case "className":
1111+ pushStringAttribute(target, "class", value);
1112+ break;
1113+ case "tabIndex":
1114+ pushStringAttribute(target, "tabindex", value);
1115+ break;
1116+ case "dir":
1117+ case "role":
1118+ case "viewBox":
1119+ case "width":
1120+ case "height":
1121+ pushStringAttribute(target, name, value);
1122+ break;
1123+ case "style":
1124+ pushStyleAttribute(target, value);
1125+ break;
1126+ case "src":
1127+ case "href":
1128+ if ("" === value) {
1129+ "src" === name
1130+ ? console.error(
1131+ 'An empty string ("") was passed to the %s attribute. This may cause the browser to download the whole page again over the network. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
1132+ name,
1133+ name
1134+ )
1135+ : console.error(
1136+ 'An empty string ("") was passed to the %s attribute. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
1137+ name,
1138+ name
1139+ );
1140+ break;
1141+ }
1142+ case "action":
1143+ case "formAction":
1144+ if (
1145+ null == value ||
1146+ "function" === typeof value ||
1147+ "symbol" === typeof value ||
1148+ "boolean" === typeof value
1149+ )
1150+ break;
1151+ checkAttributeStringCoercion(value, name);
1152+ value = sanitizeURL("" + value);
1153+ target.push(
1154+ attributeSeparator,
1155+ name,
1156+ attributeAssign,
1157+ escapeTextForBrowser(value),
1158+ attributeEnd
1159+ );
1160+ break;
1161+ case "defaultValue":
1162+ case "defaultChecked":
1163+ case "innerHTML":
1164+ case "suppressContentEditableWarning":
1165+ case "suppressHydrationWarning":
1166+ case "ref":
1167+ break;
1168+ case "autoFocus":
1169+ case "multiple":
1170+ case "muted":
1171+ pushBooleanAttribute(target, name.toLowerCase(), value);
1172+ break;
1173+ case "xlinkHref":
1174+ if (
1175+ "function" === typeof value ||
1176+ "symbol" === typeof value ||
1177+ "boolean" === typeof value
1178+ )
1179+ break;
1180+ checkAttributeStringCoercion(value, name);
1181+ value = sanitizeURL("" + value);
1182+ target.push(
1183+ attributeSeparator,
1184+ "xlink:href",
1185+ attributeAssign,
1186+ escapeTextForBrowser(value),
1187+ attributeEnd
1188+ );
1189+ break;
1190+ case "contentEditable":
1191+ case "spellCheck":
1192+ case "draggable":
1193+ case "value":
1194+ case "autoReverse":
1195+ case "externalResourcesRequired":
1196+ case "focusable":
1197+ case "preserveAlpha":
1198+ "function" !== typeof value &&
1199+ "symbol" !== typeof value &&
1200+ target.push(
1201+ attributeSeparator,
1202+ name,
1203+ attributeAssign,
1204+ escapeTextForBrowser(value),
1205+ attributeEnd
1206+ );
1207+ break;
1208+ case "inert":
1209+ "" !== value ||
1210+ didWarnForNewBooleanPropsWithEmptyValue[name] ||
1211+ ((didWarnForNewBooleanPropsWithEmptyValue[name] = !0),
1212+ console.error(
1213+ "Received an empty string for a boolean attribute `%s`. This will treat the attribute as if it were false. Either pass `false` to silence this warning, or pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.",
1214+ name
1215+ ));
1216+ case "allowFullScreen":
1217+ case "async":
1218+ case "autoPlay":
1219+ case "controls":
1220+ case "default":
1221+ case "defer":
1222+ case "disabled":
1223+ case "disablePictureInPicture":
1224+ case "disableRemotePlayback":
1225+ case "formNoValidate":
1226+ case "hidden":
1227+ case "loop":
1228+ case "noModule":
1229+ case "noValidate":
1230+ case "open":
1231+ case "playsInline":
1232+ case "readOnly":
1233+ case "required":
1234+ case "reversed":
1235+ case "scoped":
1236+ case "seamless":
1237+ case "itemScope":
1238+ value &&
1239+ "function" !== typeof value &&
1240+ "symbol" !== typeof value &&
1241+ target.push(attributeSeparator, name, attributeEmptyString);
1242+ break;
1243+ case "capture":
1244+ case "download":
1245+ !0 === value
1246+ ? target.push(attributeSeparator, name, attributeEmptyString)
1247+ : !1 !== value &&
1248+ "function" !== typeof value &&
1249+ "symbol" !== typeof value &&
1250+ target.push(
1251+ attributeSeparator,
1252+ name,
1253+ attributeAssign,
1254+ escapeTextForBrowser(value),
1255+ attributeEnd
1256+ );
1257+ break;
1258+ case "cols":
1259+ case "rows":
1260+ case "size":
1261+ case "span":
1262+ "function" !== typeof value &&
1263+ "symbol" !== typeof value &&
1264+ !isNaN(value) &&
1265+ 1 <= value &&
1266+ target.push(
1267+ attributeSeparator,
1268+ name,
1269+ attributeAssign,
1270+ escapeTextForBrowser(value),
1271+ attributeEnd
1272+ );
1273+ break;
1274+ case "rowSpan":
1275+ case "start":
1276+ "function" === typeof value ||
1277+ "symbol" === typeof value ||
1278+ isNaN(value) ||
1279+ target.push(
1280+ attributeSeparator,
1281+ name,
1282+ attributeAssign,
1283+ escapeTextForBrowser(value),
1284+ attributeEnd
1285+ );
1286+ break;
1287+ case "xlinkActuate":
1288+ pushStringAttribute(target, "xlink:actuate", value);
1289+ break;
1290+ case "xlinkArcrole":
1291+ pushStringAttribute(target, "xlink:arcrole", value);
1292+ break;
1293+ case "xlinkRole":
1294+ pushStringAttribute(target, "xlink:role", value);
1295+ break;
1296+ case "xlinkShow":
1297+ pushStringAttribute(target, "xlink:show", value);
1298+ break;
1299+ case "xlinkTitle":
1300+ pushStringAttribute(target, "xlink:title", value);
1301+ break;
1302+ case "xlinkType":
1303+ pushStringAttribute(target, "xlink:type", value);
1304+ break;
1305+ case "xmlBase":
1306+ pushStringAttribute(target, "xml:base", value);
1307+ break;
1308+ case "xmlLang":
1309+ pushStringAttribute(target, "xml:lang", value);
1310+ break;
1311+ case "xmlSpace":
1312+ pushStringAttribute(target, "xml:space", value);
1313+ break;
1314+ default:
1315+ if (
1316+ !(2 < name.length) ||
1317+ ("o" !== name[0] && "O" !== name[0]) ||
1318+ ("n" !== name[1] && "N" !== name[1])
1319+ )
1320+ if (
1321+ ((name = aliases.get(name) || name), isAttributeNameSafe(name))
1322+ ) {
1323+ switch (typeof value) {
1324+ case "function":
1325+ case "symbol":
1326+ return;
1327+ case "boolean":
1328+ var prefix = name.toLowerCase().slice(0, 5);
1329+ if ("data-" !== prefix && "aria-" !== prefix) return;
1330+ }
1331+ target.push(
1332+ attributeSeparator,
1333+ name,
1334+ attributeAssign,
1335+ escapeTextForBrowser(value),
1336+ attributeEnd
1337+ );
1338+ }
13961339 }
13971340 }
1398−
1399− var unknownPropString = unknownProps.map(function (prop) {
1400− return '`' + prop + '`';
1401− }).join(', ');
1402−
1403− if (unknownProps.length === 1) {
1404− error('Invalid value for prop %s on <%s> tag. Either remove it from the element, ' + 'or pass a string or number value to keep it in the DOM. ' + 'For details, see https://reactjs.org/link/attribute-behavior ', unknownPropString, type);
1405− } else if (unknownProps.length > 1) {
1406− error('Invalid values for props %s on <%s> tag. Either remove them from the element, ' + 'or pass a string or number value to keep them in the DOM. ' + 'For details, see https://reactjs.org/link/attribute-behavior ', unknownPropString, type);
1407− }
1408− }
1409−};
1410−
1411−function validateProperties$2(type, props, eventRegistry) {
1412− if (isCustomComponent(type, props)) {
1413− return;
1414− }
1415−
1416− warnUnknownProperties(type, props, eventRegistry);
1417−}
1418−
1419−var warnValidStyle = function () {};
1420−
1421−{
1422− // 'msTransform' is correct, but the other prefixes should be capitalized
1423− var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
1424− var msPattern = /^-ms-/;
1425− var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
1426−
1427− var badStyleValueWithSemicolonPattern = /;\s*$/;
1428− var warnedStyleNames = {};
1429− var warnedStyleValues = {};
1430− var warnedForNaNValue = false;
1431− var warnedForInfinityValue = false;
1432−
1433− var camelize = function (string) {
1434− return string.replace(hyphenPattern, function (_, character) {
1435− return character.toUpperCase();
1436− });
1437− };
1438−
1439− var warnHyphenatedStyleName = function (name) {
1440− if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
1441− return;
1442− }
1443−
1444− warnedStyleNames[name] = true;
1445−
1446− error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
1447− // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
1448− // is converted to lowercase `ms`.
1449− camelize(name.replace(msPattern, 'ms-')));
1450− };
1451−
1452− var warnBadVendoredStyleName = function (name) {
1453− if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
1454− return;
1455− }
1456−
1457− warnedStyleNames[name] = true;
1458−
1459− error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
1460− };
1461−
1462− var warnStyleValueWithSemicolon = function (name, value) {
1463− if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
1464− return;
1465− }
1466−
1467− warnedStyleValues[value] = true;
1468−
1469− error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
1470− };
1471−
1472− var warnStyleValueIsNaN = function (name, value) {
1473− if (warnedForNaNValue) {
1474− return;
1475− }
1476−
1477− warnedForNaNValue = true;
1478−
1479− error('`NaN` is an invalid value for the `%s` css style property.', name);
1480− };
1481−
1482− var warnStyleValueIsInfinity = function (name, value) {
1483− if (warnedForInfinityValue) {
1484− return;
1485− }
1486−
1487− warnedForInfinityValue = true;
1488−
1489− error('`Infinity` is an invalid value for the `%s` css style property.', name);
1490− };
1491−
1492− warnValidStyle = function (name, value) {
1493− if (name.indexOf('-') > -1) {
1494− warnHyphenatedStyleName(name);
1495− } else if (badVendoredStyleNamePattern.test(name)) {
1496− warnBadVendoredStyleName(name);
1497− } else if (badStyleValueWithSemicolonPattern.test(value)) {
1498− warnStyleValueWithSemicolon(name, value);
1499− }
1500−
1501− if (typeof value === 'number') {
1502− if (isNaN(value)) {
1503− warnStyleValueIsNaN(name, value);
1504− } else if (!isFinite(value)) {
1505− warnStyleValueIsInfinity(name, value);
1506− }
1507− }
1508− };
1509−}
1510−
1511−var warnValidStyle$1 = warnValidStyle;
1512−
1513−// code copied and modified from escape-html
1514−var matchHtmlRegExp = /["'&<>]/;
1515−/**
1516− * Escapes special characters and HTML entities in a given html string.
1517− *
1518− * @param {string} string HTML string to escape for later insertion
1519− * @return {string}
1520− * @public
1521− */
1522−
1523−function escapeHtml(string) {
1524− {
1525− checkHtmlStringCoercion(string);
1526− }
1527−
1528− var str = '' + string;
1529− var match = matchHtmlRegExp.exec(str);
1530−
1531− if (!match) {
1532− return str;
1533− }
1534−
1535− var escape;
1536− var html = '';
1537− var index;
1538− var lastIndex = 0;
1539−
1540− for (index = match.index; index < str.length; index++) {
1541− switch (str.charCodeAt(index)) {
1542− case 34:
1543− // "
1544− escape = '"';
1545− break;
1546−
1547− case 38:
1548− // &
1549− escape = '&';
1550− break;
1551−
1552− case 39:
1553− // '
1554− escape = '''; // modified from escape-html; used to be '''
1555−
1556− break;
1557−
1558− case 60:
1559− // <
1560− escape = '<';
1561− break;
1562−
1563− case 62:
1564− // >
1565− escape = '>';
1566− break;
1567−
1568− default:
1569− continue;
1570− }
1571−
1572− if (lastIndex !== index) {
1573− html += str.substring(lastIndex, index);
1574− }
1575−
1576− lastIndex = index + 1;
1577− html += escape;
1578− }
1579−
1580− return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
1581−} // end code copied and modified from escape-html
1582−
1583−/**
1584− * Escapes text to prevent scripting attacks.
1585− *
1586− * @param {*} text Text value to escape.
1587− * @return {string} An escaped string.
1588− */
1589−
1590−
1591−function escapeTextForBrowser(text) {
1592− if (typeof text === 'boolean' || typeof text === 'number') {
1593− // this shortcircuit helps perf for types that we know will never have
1594− // special characters, especially given that this function is used often
1595− // for numeric dom ids.
1596− return '' + text;
1597− }
1598−
1599− return escapeHtml(text);
1600−}
1601−
1602−var uppercasePattern = /([A-Z])/g;
1603−var msPattern$1 = /^ms-/;
1604−/**
1605− * Hyphenates a camelcased CSS property name, for example:
1606− *
1607− * > hyphenateStyleName('backgroundColor')
1608− * < "background-color"
1609− * > hyphenateStyleName('MozTransition')
1610− * < "-moz-transition"
1611− * > hyphenateStyleName('msTransition')
1612− * < "-ms-transition"
1613− *
1614− * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
1615− * is converted to `-ms-`.
1616− */
1617−
1618−function hyphenateStyleName(name) {
1619− return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern$1, '-ms-');
1620−}
1621−
1622−// and any newline or tab are filtered out as if they're not part of the URL.
1623−// https://url.spec.whatwg.org/#url-parsing
1624−// Tab or newline are defined as \r\n\t:
1625−// https://infra.spec.whatwg.org/#ascii-tab-or-newline
1626−// A C0 control is a code point in the range \u0000 NULL to \u001F
1627−// INFORMATION SEPARATOR ONE, inclusive:
1628−// https://infra.spec.whatwg.org/#c0-control-or-space
1629−
1630−/* eslint-disable max-len */
1631−
1632−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;
1633−var didWarn = false;
1634−
1635−function sanitizeURL(url) {
1636− {
1637− if (!didWarn && isJavaScriptProtocol.test(url)) {
1638− didWarn = true;
1639−
1640− 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));
1641− }
1642− }
1643−}
1644−
1645−var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
1646−
1647−function isArray(a) {
1648− return isArrayImpl(a);
1649−}
1650−
1651−var startInlineScript = stringToPrecomputedChunk('<script>');
1652−var endInlineScript = stringToPrecomputedChunk('</script>');
1653−var startScriptSrc = stringToPrecomputedChunk('<script src="');
1654−var startModuleSrc = stringToPrecomputedChunk('<script type="module" src="');
1655−var endAsyncScript = stringToPrecomputedChunk('" async=""></script>');
1656−/**
1657− * This escaping function is designed to work with bootstrapScriptContent only.
1658− * because we know we are escaping the entire script. We can avoid for instance
1659− * escaping html comment string sequences that are valid javascript as well because
1660− * if there are no sebsequent <script sequences the html parser will never enter
1661− * script data double escaped state (see: https://www.w3.org/TR/html53/syntax.html#script-data-double-escaped-state)
1662− *
1663− * While untrusted script content should be made safe before using this api it will
1664− * ensure that the script cannot be early terminated or never terminated state
1665− */
1666−
1667−function escapeBootstrapScriptContent(scriptText) {
1668− {
1669− checkHtmlStringCoercion(scriptText);
1670− }
1671−
1672− return ('' + scriptText).replace(scriptRegex, scriptReplacer);
1673−}
1674−
1675−var scriptRegex = /(<\/|<)(s)(cript)/gi;
1676−
1677−var scriptReplacer = function (match, prefix, s, suffix) {
1678− return "" + prefix + (s === 's' ? "\\u0073" : "\\u0053") + suffix;
1679−}; // Allows us to keep track of what we've already written so we can refer back to it.
1680−
1681−
1682−function createResponseState(identifierPrefix, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
1683− var idPrefix = identifierPrefix === undefined ? '' : identifierPrefix;
1684− var inlineScriptWithNonce = nonce === undefined ? startInlineScript : stringToPrecomputedChunk('<script nonce="' + escapeTextForBrowser(nonce) + '">');
1685− var bootstrapChunks = [];
1686−
1687− if (bootstrapScriptContent !== undefined) {
1688− bootstrapChunks.push(inlineScriptWithNonce, stringToChunk(escapeBootstrapScriptContent(bootstrapScriptContent)), endInlineScript);
1689− }
1690−
1691− if (bootstrapScripts !== undefined) {
1692− for (var i = 0; i < bootstrapScripts.length; i++) {
1693− bootstrapChunks.push(startScriptSrc, stringToChunk(escapeTextForBrowser(bootstrapScripts[i])), endAsyncScript);
1694− }
1695− }
1696−
1697− if (bootstrapModules !== undefined) {
1698− for (var _i = 0; _i < bootstrapModules.length; _i++) {
1699− bootstrapChunks.push(startModuleSrc, stringToChunk(escapeTextForBrowser(bootstrapModules[_i])), endAsyncScript);
1700− }
1701− }
1702−
1703− return {
1704− bootstrapChunks: bootstrapChunks,
1705− startInlineScript: inlineScriptWithNonce,
1706− placeholderPrefix: stringToPrecomputedChunk(idPrefix + 'P:'),
1707− segmentPrefix: stringToPrecomputedChunk(idPrefix + 'S:'),
1708− boundaryPrefix: idPrefix + 'B:',
1709− idPrefix: idPrefix,
1710− nextSuspenseID: 0,
1711− sentCompleteSegmentFunction: false,
1712− sentCompleteBoundaryFunction: false,
1713− sentClientRenderFunction: false
1714− };
1715−} // Constants for the insertion mode we're currently writing in. We don't encode all HTML5 insertion
1716−// modes. We only include the variants as they matter for the sake of our purposes.
1717−// We don't actually provide the namespace therefore we use constants instead of the string.
1718−
1719−var ROOT_HTML_MODE = 0; // Used for the root most element tag.
1720−
1721−var HTML_MODE = 1;
1722−var SVG_MODE = 2;
1723−var MATHML_MODE = 3;
1724−var HTML_TABLE_MODE = 4;
1725−var HTML_TABLE_BODY_MODE = 5;
1726−var HTML_TABLE_ROW_MODE = 6;
1727−var HTML_COLGROUP_MODE = 7; // We have a greater than HTML_TABLE_MODE check elsewhere. If you add more cases here, make sure it
1728−// still makes sense
1729−
1730−function createFormatContext(insertionMode, selectedValue) {
1731− return {
1732− insertionMode: insertionMode,
1733− selectedValue: selectedValue
1734− };
1735−}
1736−function getChildFormatContext(parentContext, type, props) {
1737− switch (type) {
1738− case 'select':
1739− return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue);
1740−
1741− case 'svg':
1742− return createFormatContext(SVG_MODE, null);
1743−
1744− case 'math':
1745− return createFormatContext(MATHML_MODE, null);
1746−
1747− case 'foreignObject':
1748− return createFormatContext(HTML_MODE, null);
1749− // Table parents are special in that their children can only be created at all if they're
1750− // wrapped in a table parent. So we need to encode that we're entering this mode.
1751−
1752− case 'table':
1753− return createFormatContext(HTML_TABLE_MODE, null);
1754−
1755− case 'thead':
1756− case 'tbody':
1757− case 'tfoot':
1758− return createFormatContext(HTML_TABLE_BODY_MODE, null);
1759−
1760− case 'colgroup':
1761− return createFormatContext(HTML_COLGROUP_MODE, null);
1762−
1763− case 'tr':
1764− return createFormatContext(HTML_TABLE_ROW_MODE, null);
1765− }
1766−
1767− if (parentContext.insertionMode >= HTML_TABLE_MODE) {
1768− // Whatever tag this was, it wasn't a table parent or other special parent, so we must have
1769− // entered plain HTML again.
1770− return createFormatContext(HTML_MODE, null);
1771− }
1772−
1773− if (parentContext.insertionMode === ROOT_HTML_MODE) {
1774− // We've emitted the root and is now in plain HTML mode.
1775− return createFormatContext(HTML_MODE, null);
1776− }
1777−
1778− return parentContext;
1779−}
1780−var UNINITIALIZED_SUSPENSE_BOUNDARY_ID = null;
1781−function assignSuspenseBoundaryID(responseState) {
1782− var generatedID = responseState.nextSuspenseID++;
1783− return stringToPrecomputedChunk(responseState.boundaryPrefix + generatedID.toString(16));
1784−}
1785−function makeId(responseState, treeId, localId) {
1786− var idPrefix = responseState.idPrefix;
1787− var id = ':' + idPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end
1788− // that represents the position of this useId hook among all the useId
1789− // hooks for this fiber.
1790−
1791− if (localId > 0) {
1792− id += 'H' + localId.toString(32);
1793− }
1794−
1795− return id + ':';
1796−}
1797−
1798−function encodeHTMLTextNode(text) {
1799− return escapeTextForBrowser(text);
1800−}
1801−
1802−var textSeparator = stringToPrecomputedChunk('<!-- -->');
1803−function pushTextInstance(target, text, responseState, textEmbedded) {
1804− if (text === '') {
1805− // Empty text doesn't have a DOM node representation and the hydration is aware of this.
1806− return textEmbedded;
1807− }
1808−
1809− if (textEmbedded) {
1810− target.push(textSeparator);
1811− }
1812−
1813− target.push(stringToChunk(encodeHTMLTextNode(text)));
1814− return true;
1815−} // Called when Fizz is done with a Segment. Currently the only purpose is to conditionally
1816−// emit a text separator when we don't know for sure it is safe to omit
1817−
1818−function pushSegmentFinale(target, responseState, lastPushedText, textEmbedded) {
1819− if (lastPushedText && textEmbedded) {
1820− target.push(textSeparator);
1821− }
1822−}
1823−var styleNameCache = new Map();
1824−
1825−function processStyleName(styleName) {
1826− var chunk = styleNameCache.get(styleName);
1827−
1828− if (chunk !== undefined) {
1829− return chunk;
1830− }
1831−
1832− var result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
1833− styleNameCache.set(styleName, result);
1834− return result;
1835−}
1836−
1837−var styleAttributeStart = stringToPrecomputedChunk(' style="');
1838−var styleAssign = stringToPrecomputedChunk(':');
1839−var styleSeparator = stringToPrecomputedChunk(';');
1840−
1841−function pushStyle(target, responseState, style) {
1842− if (typeof style !== 'object') {
1843− 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.');
1844− }
1845−
1846− var isFirst = true;
1847−
1848− for (var styleName in style) {
1849− if (!hasOwnProperty.call(style, styleName)) {
1850− continue;
1851− } // If you provide unsafe user data here they can inject arbitrary CSS
1852− // which may be problematic (I couldn't repro this):
1853− // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
1854− // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
1855− // This is not an XSS hole but instead a potential CSS injection issue
1856− // which has lead to a greater discussion about how we're going to
1857− // trust URLs moving forward. See #2115901
1858−
1859−
1860− var styleValue = style[styleName];
1861−
1862− if (styleValue == null || typeof styleValue === 'boolean' || styleValue === '') {
1863− // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
1864− continue;
1865− }
1866−
1867− var nameChunk = void 0;
1868− var valueChunk = void 0;
1869− var isCustomProperty = styleName.indexOf('--') === 0;
1870−
1871− if (isCustomProperty) {
1872− nameChunk = stringToChunk(escapeTextForBrowser(styleName));
1873−
1874− {
1875− checkCSSPropertyStringCoercion(styleValue, styleName);
1876− }
1877−
1878− valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
1879− } else {
1880− {
1881− warnValidStyle$1(styleName, styleValue);
1882− }
1883−
1884− nameChunk = processStyleName(styleName);
1885−
1886− if (typeof styleValue === 'number') {
1887− if (styleValue !== 0 && !hasOwnProperty.call(isUnitlessNumber, styleName)) {
1888− valueChunk = stringToChunk(styleValue + 'px'); // Presumes implicit 'px' suffix for unitless numbers
1889− } else {
1890− valueChunk = stringToChunk('' + styleValue);
1891− }
1892− } else {
1893− {
1894− checkCSSPropertyStringCoercion(styleValue, styleName);
1895− }
1896−
1897− valueChunk = stringToChunk(escapeTextForBrowser(('' + styleValue).trim()));
1898− }
1899− }
1900−
1901− if (isFirst) {
1902− isFirst = false; // If it's first, we don't need any separators prefixed.
1903−
1904− target.push(styleAttributeStart, nameChunk, styleAssign, valueChunk);
1905− } else {
1906− target.push(styleSeparator, nameChunk, styleAssign, valueChunk);
1907− }
1908− }
1909−
1910− if (!isFirst) {
1911− target.push(attributeEnd);
1912− }
1913−}
1914−
1915−var attributeSeparator = stringToPrecomputedChunk(' ');
1916−var attributeAssign = stringToPrecomputedChunk('="');
1917−var attributeEnd = stringToPrecomputedChunk('"');
1918−var attributeEmptyString = stringToPrecomputedChunk('=""');
1919−
1920−function pushAttribute(target, responseState, name, value) {
1921− switch (name) {
1922− case 'style':
1923− {
1924− pushStyle(target, responseState, value);
1925− return;
1926− }
1927−
1928− case 'defaultValue':
1929− case 'defaultChecked': // These shouldn't be set as attributes on generic HTML elements.
1930−
1931− case 'innerHTML': // Must use dangerouslySetInnerHTML instead.
1932−
1933− case 'suppressContentEditableWarning':
1934− case 'suppressHydrationWarning':
1935− // Ignored. These are built-in to React on the client.
1936− return;
1937− }
1938−
1939− if ( // shouldIgnoreAttribute
1940− // We have already filtered out null/undefined and reserved words.
1941− name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
1942− return;
1943− }
1944−
1945− var propertyInfo = getPropertyInfo(name);
1946−
1947− if (propertyInfo !== null) {
1948− // shouldRemoveAttribute
1949− switch (typeof value) {
1950− case 'function': // $FlowIssue symbol is perfectly valid here
1951−
1952− case 'symbol':
1953− // eslint-disable-line
1954− return;
1955−
1956− case 'boolean':
1957− {
1958− if (!propertyInfo.acceptsBooleans) {
1959− return;
1960− }
1341+ function pushInnerHTML(target, innerHTML, children) {
1342+ if (null != innerHTML) {
1343+ if (null != children)
1344+ throw Error(
1345+ "Can only set one of `children` or `props.dangerouslySetInnerHTML`."
1346+ );
1347+ if ("object" !== typeof innerHTML || !("__html" in innerHTML))
1348+ throw Error(
1349+ "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://react.dev/link/dangerously-set-inner-html for more information."
1350+ );
1351+ innerHTML = innerHTML.__html;
1352+ null !== innerHTML &&
1353+ void 0 !== innerHTML &&
1354+ (checkHtmlStringCoercion(innerHTML), target.push("" + innerHTML));
1355+ }
1356+ }
1357+ function checkSelectProp(props, propName) {
1358+ var value = props[propName];
1359+ null != value &&
1360+ ((value = isArrayImpl(value)),
1361+ props.multiple && !value
1362+ ? console.error(
1363+ "The `%s` prop supplied to <select> must be an array if `multiple` is true.",
1364+ propName
1365+ )
1366+ : !props.multiple &&
1367+ value &&
1368+ console.error(
1369+ "The `%s` prop supplied to <select> must be a scalar value if `multiple` is false.",
1370+ propName
1371+ ));
1372+ }
1373+ function flattenOptionChildren(children) {
1374+ var content = "";
1375+ React.Children.forEach(children, function (child) {
1376+ null != child &&
1377+ ((content += child),
1378+ didWarnInvalidOptionChildren ||
1379+ "string" === typeof child ||
1380+ "number" === typeof child ||
1381+ "bigint" === typeof child ||
1382+ ((didWarnInvalidOptionChildren = !0),
1383+ console.error(
1384+ "Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to <option>."
1385+ )));
1386+ });
1387+ return content;
1388+ }
1389+ function injectFormReplayingRuntime(resumableState, renderState) {
1390+ if ((resumableState.instructions & 16) === NothingSent) {
1391+ resumableState.instructions |= 16;
1392+ var preamble = renderState.preamble,
1393+ bootstrapChunks = renderState.bootstrapChunks;
1394+ (preamble.htmlChunks || preamble.headChunks) &&
1395+ 0 === bootstrapChunks.length
1396+ ? (bootstrapChunks.push(renderState.startInlineScript),
1397+ pushCompletedShellIdAttribute(bootstrapChunks, resumableState),
1398+ bootstrapChunks.push(
1399+ endOfStartTag,
1400+ formReplayingRuntimeScript,
1401+ endInlineScript
1402+ ))
1403+ : bootstrapChunks.unshift(
1404+ renderState.startInlineScript,
1405+ endOfStartTag,
1406+ formReplayingRuntimeScript,
1407+ endInlineScript
1408+ );
1409+ }
1410+ }
1411+ function pushLinkImpl(target, props) {
1412+ target.push(startChunkForTag("link"));
1413+ for (var propKey in props)
1414+ if (hasOwnProperty.call(props, propKey)) {
1415+ var propValue = props[propKey];
1416+ if (null != propValue)
1417+ switch (propKey) {
1418+ case "children":
1419+ case "dangerouslySetInnerHTML":
1420+ throw Error(
1421+ "link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
1422+ );
1423+ default:
1424+ pushAttribute(target, propKey, propValue);
1425+ }
19611426 }
1962− }
1963−
1964− var attributeName = propertyInfo.attributeName;
1965− var attributeNameChunk = stringToChunk(attributeName); // TODO: If it's known we can cache the chunk.
1966−
1967− switch (propertyInfo.type) {
1968− case BOOLEAN:
1969− if (value) {
1970− target.push(attributeSeparator, attributeNameChunk, attributeEmptyString);
1427+ target.push(endOfStartTagSelfClosing);
1428+ return null;
1429+ }
1430+ function escapeStyleTextContent(styleText) {
1431+ checkHtmlStringCoercion(styleText);
1432+ return ("" + styleText).replace(styleRegex, styleReplacer);
1433+ }
1434+ function pushSelfClosing(target, props, tag) {
1435+ target.push(startChunkForTag(tag));
1436+ for (var propKey in props)
1437+ if (hasOwnProperty.call(props, propKey)) {
1438+ var propValue = props[propKey];
1439+ if (null != propValue)
1440+ switch (propKey) {
1441+ case "children":
1442+ case "dangerouslySetInnerHTML":
1443+ throw Error(
1444+ tag +
1445+ " is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
1446+ );
1447+ default:
1448+ pushAttribute(target, propKey, propValue);
1449+ }
19711450 }
1972−
1973− return;
1974−
1975− case OVERLOADED_BOOLEAN:
1976− if (value === true) {
1977− target.push(attributeSeparator, attributeNameChunk, attributeEmptyString);
1978− } else if (value === false) ; else {
1979− target.push(attributeSeparator, attributeNameChunk, attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
1451+ target.push(endOfStartTagSelfClosing);
1452+ return null;
1453+ }
1454+ function pushTitleImpl(target, props) {
1455+ target.push(startChunkForTag("title"));
1456+ var children = null,
1457+ innerHTML = null,
1458+ propKey;
1459+ for (propKey in props)
1460+ if (hasOwnProperty.call(props, propKey)) {
1461+ var propValue = props[propKey];
1462+ if (null != propValue)
1463+ switch (propKey) {
1464+ case "children":
1465+ children = propValue;
1466+ break;
1467+ case "dangerouslySetInnerHTML":
1468+ innerHTML = propValue;
1469+ break;
1470+ default:
1471+ pushAttribute(target, propKey, propValue);
1472+ }
19801473 }
1981−
1982− return;
1983−
1984− case NUMERIC:
1985− if (!isNaN(value)) {
1986− target.push(attributeSeparator, attributeNameChunk, attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
1474+ target.push(endOfStartTag);
1475+ props = Array.isArray(children)
1476+ ? 2 > children.length
1477+ ? children[0]
1478+ : null
1479+ : children;
1480+ "function" !== typeof props &&
1481+ "symbol" !== typeof props &&
1482+ null !== props &&
1483+ void 0 !== props &&
1484+ target.push(escapeTextForBrowser("" + props));
1485+ pushInnerHTML(target, innerHTML, children);
1486+ target.push(endChunkForTag("title"));
1487+ return null;
1488+ }
1489+ function pushScriptImpl(target, props) {
1490+ target.push(startChunkForTag("script"));
1491+ var children = null,
1492+ innerHTML = null,
1493+ propKey;
1494+ for (propKey in props)
1495+ if (hasOwnProperty.call(props, propKey)) {
1496+ var propValue = props[propKey];
1497+ if (null != propValue)
1498+ switch (propKey) {
1499+ case "children":
1500+ children = propValue;
1501+ break;
1502+ case "dangerouslySetInnerHTML":
1503+ innerHTML = propValue;
1504+ break;
1505+ default:
1506+ pushAttribute(target, propKey, propValue);
1507+ }
19871508 }
1988−
1989− break;
1990−
1991− case POSITIVE_NUMERIC:
1992− if (!isNaN(value) && value >= 1) {
1993− target.push(attributeSeparator, attributeNameChunk, attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
1509+ target.push(endOfStartTag);
1510+ null != children &&
1511+ "string" !== typeof children &&
1512+ ((props =
1513+ "number" === typeof children
1514+ ? "a number for children"
1515+ : Array.isArray(children)
1516+ ? "an array for children"
1517+ : "something unexpected for children"),
1518+ console.error(
1519+ "A script element was rendered with %s. If script element has children it must be a single string. Consider using dangerouslySetInnerHTML or passing a plain string as children.",
1520+ props
1521+ ));
1522+ pushInnerHTML(target, innerHTML, children);
1523+ "string" === typeof children &&
1524+ target.push(escapeEntireInlineScriptContent(children));
1525+ target.push(endChunkForTag("script"));
1526+ return null;
1527+ }
1528+ function pushStartSingletonElement(target, props, tag) {
1529+ target.push(startChunkForTag(tag));
1530+ var innerHTML = (tag = null),
1531+ propKey;
1532+ for (propKey in props)
1533+ if (hasOwnProperty.call(props, propKey)) {
1534+ var propValue = props[propKey];
1535+ if (null != propValue)
1536+ switch (propKey) {
1537+ case "children":
1538+ tag = propValue;
1539+ break;
1540+ case "dangerouslySetInnerHTML":
1541+ innerHTML = propValue;
1542+ break;
1543+ default:
1544+ pushAttribute(target, propKey, propValue);
1545+ }
19941546 }
1995−
1996− break;
1997−
1998− default:
1999− if (propertyInfo.sanitizeURL) {
2000− {
2001− checkAttributeStringCoercion(value, attributeName);
2002− }
2003−
2004− value = '' + value;
2005− sanitizeURL(value);
1547+ target.push(endOfStartTag);
1548+ pushInnerHTML(target, innerHTML, tag);
1549+ return tag;
1550+ }
1551+ function pushStartGenericElement(target, props, tag) {
1552+ target.push(startChunkForTag(tag));
1553+ var innerHTML = (tag = null),
1554+ propKey;
1555+ for (propKey in props)
1556+ if (hasOwnProperty.call(props, propKey)) {
1557+ var propValue = props[propKey];
1558+ if (null != propValue)
1559+ switch (propKey) {
1560+ case "children":
1561+ tag = propValue;
1562+ break;
1563+ case "dangerouslySetInnerHTML":
1564+ innerHTML = propValue;
1565+ break;
1566+ default:
1567+ pushAttribute(target, propKey, propValue);
1568+ }
20061569 }
2007−
2008− target.push(attributeSeparator, attributeNameChunk, attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
2009− }
2010− } else if (isAttributeNameSafe(name)) {
2011− // shouldRemoveAttribute
2012− switch (typeof value) {
2013− case 'function': // $FlowIssue symbol is perfectly valid here
2014−
2015− case 'symbol':
2016− // eslint-disable-line
2017− return;
2018−
2019− case 'boolean':
2020− {
2021− var prefix = name.toLowerCase().slice(0, 5);
2022−
2023− if (prefix !== 'data-' && prefix !== 'aria-') {
2024− return;
2025− }
1570+ target.push(endOfStartTag);
1571+ pushInnerHTML(target, innerHTML, tag);
1572+ return "string" === typeof tag
1573+ ? (target.push(escapeTextForBrowser(tag)), null)
1574+ : tag;
1575+ }
1576+ function startChunkForTag(tag) {
1577+ var tagStartChunk = validatedTagCache.get(tag);
1578+ if (void 0 === tagStartChunk) {
1579+ if (!VALID_TAG_REGEX.test(tag)) throw Error("Invalid tag: " + tag);
1580+ tagStartChunk = "<" + tag;
1581+ validatedTagCache.set(tag, tagStartChunk);
1582+ }
1583+ return tagStartChunk;
1584+ }
1585+ function pushStartInstance(
1586+ target$jscomp$0,
1587+ type,
1588+ props,
1589+ resumableState,
1590+ renderState,
1591+ preambleState,
1592+ hoistableState,
1593+ formatContext,
1594+ textEmbedded
1595+ ) {
1596+ validateProperties$2(type, props);
1597+ ("input" !== type && "textarea" !== type && "select" !== type) ||
1598+ null == props ||
1599+ null !== props.value ||
1600+ didWarnValueNull ||
1601+ ((didWarnValueNull = !0),
1602+ "select" === type && props.multiple
1603+ ? console.error(
1604+ "`value` prop on `%s` should not be null. Consider using an empty array when `multiple` is set to `true` to clear the component or `undefined` for uncontrolled components.",
1605+ type
1606+ )
1607+ : console.error(
1608+ "`value` prop on `%s` should not be null. Consider using an empty string to clear the component or `undefined` for uncontrolled components.",
1609+ type
1610+ ));
1611+ b: if (-1 === type.indexOf("-")) var JSCompiler_inline_result = !1;
1612+ else
1613+ switch (type) {
1614+ case "annotation-xml":
1615+ case "color-profile":
1616+ case "font-face":
1617+ case "font-face-src":
1618+ case "font-face-uri":
1619+ case "font-face-format":
1620+ case "font-face-name":
1621+ case "missing-glyph":
1622+ JSCompiler_inline_result = !1;
1623+ break b;
1624+ default:
1625+ JSCompiler_inline_result = !0;
20261626 }
2027− }
2028−
2029− target.push(attributeSeparator, stringToChunk(name), attributeAssign, stringToChunk(escapeTextForBrowser(value)), attributeEnd);
2030− }
2031−}
2032−
2033−var endOfStartTag = stringToPrecomputedChunk('>');
2034−var endOfStartTagSelfClosing = stringToPrecomputedChunk('/>');
2035−
2036−function pushInnerHTML(target, innerHTML, children) {
2037− if (innerHTML != null) {
2038− if (children != null) {
2039− throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
2040− }
2041−
2042− if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
2043− throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
2044− }
2045−
2046− var html = innerHTML.__html;
2047−
2048− if (html !== null && html !== undefined) {
2049− {
2050− checkHtmlStringCoercion(html);
2051− }
2052−
2053− target.push(stringToChunk('' + html));
2054− }
2055− }
2056−} // TODO: Move these to ResponseState so that we warn for every request.
2057−// It would help debugging in stateful servers (e.g. service worker).
2058−
2059−
2060−var didWarnDefaultInputValue = false;
2061−var didWarnDefaultChecked = false;
2062−var didWarnDefaultSelectValue = false;
2063−var didWarnDefaultTextareaValue = false;
2064−var didWarnInvalidOptionChildren = false;
2065−var didWarnInvalidOptionInnerHTML = false;
2066−var didWarnSelectedSetOnOption = false;
2067−
2068−function checkSelectProp(props, propName) {
2069− {
2070− var value = props[propName];
2071−
2072− if (value != null) {
2073− var array = isArray(value);
2074−
2075− if (props.multiple && !array) {
2076− error('The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.', propName);
2077− } else if (!props.multiple && array) {
2078− error('The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.', propName);
2079− }
2080− }
2081− }
2082−}
2083−
2084−function pushStartSelect(target, props, responseState) {
2085− {
2086− checkControlledValueProps('select', props);
2087− checkSelectProp(props, 'value');
2088− checkSelectProp(props, 'defaultValue');
2089−
2090− if (props.value !== undefined && props.defaultValue !== undefined && !didWarnDefaultSelectValue) {
2091− 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');
2092−
2093− didWarnDefaultSelectValue = true;
2094− }
2095− }
2096−
2097− target.push(startChunkForTag('select'));
2098− var children = null;
2099− var innerHTML = null;
2100−
2101− for (var propKey in props) {
2102− if (hasOwnProperty.call(props, propKey)) {
2103− var propValue = props[propKey];
2104−
2105− if (propValue == null) {
2106− continue;
2107− }
2108−
2109− switch (propKey) {
2110− case 'children':
2111− children = propValue;
2112− break;
2113−
2114− case 'dangerouslySetInnerHTML':
2115− // TODO: This doesn't really make sense for select since it can't use the controlled
2116− // value in the innerHTML.
2117− innerHTML = propValue;
2118− break;
2119−
2120− case 'defaultValue':
2121− case 'value':
2122− // These are set on the Context instead and applied to the nested options.
2123− break;
2124−
2125− default:
2126− pushAttribute(target, responseState, propKey, propValue);
1627+ JSCompiler_inline_result ||
1628+ "string" === typeof props.is ||
1629+ warnUnknownProperties(type, props, null);
1630+ !props.suppressContentEditableWarning &&
1631+ props.contentEditable &&
1632+ null != props.children &&
1633+ console.error(
1634+ "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."
1635+ );
1636+ formatContext.insertionMode !== SVG_MODE &&
1637+ formatContext.insertionMode !== MATHML_MODE &&
1638+ -1 === type.indexOf("-") &&
1639+ type.toLowerCase() !== type &&
1640+ console.error(
1641+ "<%s /> is using incorrect casing. Use PascalCase for React components, or lowercase for HTML elements.",
1642+ type
1643+ );
1644+ switch (type) {
1645+ case "div":
1646+ case "span":
1647+ case "svg":
1648+ case "path":
21271649 break;
2128− }
2129− }
2130− }
2131−
2132− target.push(endOfStartTag);
2133− pushInnerHTML(target, innerHTML, children);
2134− return children;
2135−}
2136−
2137−function flattenOptionChildren(children) {
2138− var content = ''; // Flatten children and warn if they aren't strings or numbers;
2139− // invalid types are ignored.
2140−
2141− React.Children.forEach(children, function (child) {
2142− if (child == null) {
2143− return;
2144− }
2145−
2146− content += child;
2147−
2148− {
2149− if (!didWarnInvalidOptionChildren && typeof child !== 'string' && typeof child !== 'number') {
2150− didWarnInvalidOptionChildren = true;
2151−
2152− error('Cannot infer the option value of complex children. ' + 'Pass a `value` prop or use a plain string as children to <option>.');
2153− }
2154− }
2155− });
2156− return content;
2157−}
2158−
2159−var selectedMarkerAttribute = stringToPrecomputedChunk(' selected=""');
2160−
2161−function pushStartOption(target, props, responseState, formatContext) {
2162− var selectedValue = formatContext.selectedValue;
2163− target.push(startChunkForTag('option'));
2164− var children = null;
2165− var value = null;
2166− var selected = null;
2167− var innerHTML = null;
2168−
2169− for (var propKey in props) {
2170− if (hasOwnProperty.call(props, propKey)) {
2171− var propValue = props[propKey];
2172−
2173− if (propValue == null) {
2174− continue;
2175− }
2176−
2177− switch (propKey) {
2178− case 'children':
2179− children = propValue;
1650+ case "a":
1651+ target$jscomp$0.push(startChunkForTag("a"));
1652+ var children = null,
1653+ innerHTML = null,
1654+ propKey;
1655+ for (propKey in props)
1656+ if (hasOwnProperty.call(props, propKey)) {
1657+ var propValue = props[propKey];
1658+ if (null != propValue)
1659+ switch (propKey) {
1660+ case "children":
1661+ children = propValue;
1662+ break;
1663+ case "dangerouslySetInnerHTML":
1664+ innerHTML = propValue;
1665+ break;
1666+ case "href":
1667+ "" === propValue
1668+ ? pushStringAttribute(target$jscomp$0, "href", "")
1669+ : pushAttribute(target$jscomp$0, propKey, propValue);
1670+ break;
1671+ default:
1672+ pushAttribute(target$jscomp$0, propKey, propValue);
1673+ }
1674+ }
1675+ target$jscomp$0.push(endOfStartTag);
1676+ pushInnerHTML(target$jscomp$0, innerHTML, children);
1677+ if ("string" === typeof children) {
1678+ target$jscomp$0.push(escapeTextForBrowser(children));
1679+ var JSCompiler_inline_result$jscomp$0 = null;
1680+ } else JSCompiler_inline_result$jscomp$0 = children;
1681+ return JSCompiler_inline_result$jscomp$0;
1682+ case "g":
1683+ case "p":
1684+ case "li":
21801685 break;
2181−
2182− case 'selected':
2183− // ignore
2184− selected = propValue;
2185−
2186− {
2187− // TODO: Remove support for `selected` in <option>.
2188− if (!didWarnSelectedSetOnOption) {
2189− error('Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.');
2190−
2191− didWarnSelectedSetOnOption = true;
1686+ case "select":
1687+ checkControlledValueProps("select", props);
1688+ checkSelectProp(props, "value");
1689+ checkSelectProp(props, "defaultValue");
1690+ void 0 === props.value ||
1691+ void 0 === props.defaultValue ||
1692+ didWarnDefaultSelectValue ||
1693+ (console.error(
1694+ "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://react.dev/link/controlled-components"
1695+ ),
1696+ (didWarnDefaultSelectValue = !0));
1697+ target$jscomp$0.push(startChunkForTag("select"));
1698+ var children$jscomp$0 = null,
1699+ innerHTML$jscomp$0 = null,
1700+ propKey$jscomp$0;
1701+ for (propKey$jscomp$0 in props)
1702+ if (hasOwnProperty.call(props, propKey$jscomp$0)) {
1703+ var propValue$jscomp$0 = props[propKey$jscomp$0];
1704+ if (null != propValue$jscomp$0)
1705+ switch (propKey$jscomp$0) {
1706+ case "children":
1707+ children$jscomp$0 = propValue$jscomp$0;
1708+ break;
1709+ case "dangerouslySetInnerHTML":
1710+ innerHTML$jscomp$0 = propValue$jscomp$0;
1711+ break;
1712+ case "defaultValue":
1713+ case "value":
1714+ break;
1715+ default:
1716+ pushAttribute(
1717+ target$jscomp$0,
1718+ propKey$jscomp$0,
1719+ propValue$jscomp$0
1720+ );
1721+ }
1722+ }
1723+ target$jscomp$0.push(endOfStartTag);
1724+ pushInnerHTML(target$jscomp$0, innerHTML$jscomp$0, children$jscomp$0);
1725+ return children$jscomp$0;
1726+ case "option":
1727+ var selectedValue = formatContext.selectedValue;
1728+ target$jscomp$0.push(startChunkForTag("option"));
1729+ var children$jscomp$1 = null,
1730+ value = null,
1731+ selected = null,
1732+ innerHTML$jscomp$1 = null,
1733+ propKey$jscomp$1;
1734+ for (propKey$jscomp$1 in props)
1735+ if (hasOwnProperty.call(props, propKey$jscomp$1)) {
1736+ var propValue$jscomp$1 = props[propKey$jscomp$1];
1737+ if (null != propValue$jscomp$1)
1738+ switch (propKey$jscomp$1) {
1739+ case "children":
1740+ children$jscomp$1 = propValue$jscomp$1;
1741+ break;
1742+ case "selected":
1743+ selected = propValue$jscomp$1;
1744+ didWarnSelectedSetOnOption ||
1745+ (console.error(
1746+ "Use the `defaultValue` or `value` props on <select> instead of setting `selected` on <option>."
1747+ ),
1748+ (didWarnSelectedSetOnOption = !0));
1749+ break;
1750+ case "dangerouslySetInnerHTML":
1751+ innerHTML$jscomp$1 = propValue$jscomp$1;
1752+ break;
1753+ case "value":
1754+ value = propValue$jscomp$1;
1755+ default:
1756+ pushAttribute(
1757+ target$jscomp$0,
1758+ propKey$jscomp$1,
1759+ propValue$jscomp$1
1760+ );
1761+ }
1762+ }
1763+ if (null != selectedValue) {
1764+ if (null !== value) {
1765+ checkAttributeStringCoercion(value, "value");
1766+ var stringValue = "" + value;
1767+ } else
1768+ null === innerHTML$jscomp$1 ||
1769+ didWarnInvalidOptionInnerHTML ||
1770+ ((didWarnInvalidOptionInnerHTML = !0),
1771+ console.error(
1772+ "Pass a `value` prop if you set dangerouslyInnerHTML so React knows which value should be selected."
1773+ )),
1774+ (stringValue = flattenOptionChildren(children$jscomp$1));
1775+ if (isArrayImpl(selectedValue))
1776+ for (var i = 0; i < selectedValue.length; i++) {
1777+ if (
1778+ (checkAttributeStringCoercion(selectedValue[i], "value"),
1779+ "" + selectedValue[i] === stringValue)
1780+ ) {
1781+ target$jscomp$0.push(' selected=""');
1782+ break;
1783+ }
1784+ }
1785+ else
1786+ checkAttributeStringCoercion(selectedValue, "select.value"),
1787+ "" + selectedValue === stringValue &&
1788+ target$jscomp$0.push(' selected=""');
1789+ } else selected && target$jscomp$0.push(' selected=""');
1790+ target$jscomp$0.push(endOfStartTag);
1791+ pushInnerHTML(target$jscomp$0, innerHTML$jscomp$1, children$jscomp$1);
1792+ return children$jscomp$1;
1793+ case "textarea":
1794+ checkControlledValueProps("textarea", props);
1795+ void 0 === props.value ||
1796+ void 0 === props.defaultValue ||
1797+ didWarnDefaultTextareaValue ||
1798+ (console.error(
1799+ "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://react.dev/link/controlled-components"
1800+ ),
1801+ (didWarnDefaultTextareaValue = !0));
1802+ target$jscomp$0.push(startChunkForTag("textarea"));
1803+ var value$jscomp$0 = null,
1804+ defaultValue = null,
1805+ children$jscomp$2 = null,
1806+ propKey$jscomp$2;
1807+ for (propKey$jscomp$2 in props)
1808+ if (hasOwnProperty.call(props, propKey$jscomp$2)) {
1809+ var propValue$jscomp$2 = props[propKey$jscomp$2];
1810+ if (null != propValue$jscomp$2)
1811+ switch (propKey$jscomp$2) {
1812+ case "children":
1813+ children$jscomp$2 = propValue$jscomp$2;
1814+ break;
1815+ case "value":
1816+ value$jscomp$0 = propValue$jscomp$2;
1817+ break;
1818+ case "defaultValue":
1819+ defaultValue = propValue$jscomp$2;
1820+ break;
1821+ case "dangerouslySetInnerHTML":
1822+ throw Error(
1823+ "`dangerouslySetInnerHTML` does not make sense on <textarea>."
1824+ );
1825+ default:
1826+ pushAttribute(
1827+ target$jscomp$0,
1828+ propKey$jscomp$2,
1829+ propValue$jscomp$2
1830+ );
1831+ }
1832+ }
1833+ null === value$jscomp$0 &&
1834+ null !== defaultValue &&
1835+ (value$jscomp$0 = defaultValue);
1836+ target$jscomp$0.push(endOfStartTag);
1837+ if (null != children$jscomp$2) {
1838+ console.error(
1839+ "Use the `defaultValue` or `value` props instead of setting children on <textarea>."
1840+ );
1841+ if (null != value$jscomp$0)
1842+ throw Error(
1843+ "If you supply `defaultValue` on a <textarea>, do not pass children."
1844+ );
1845+ if (isArrayImpl(children$jscomp$2)) {
1846+ if (1 < children$jscomp$2.length)
1847+ throw Error("<textarea> can only have at most one child.");
1848+ checkHtmlStringCoercion(children$jscomp$2[0]);
1849+ value$jscomp$0 = "" + children$jscomp$2[0];
21921850 }
1851+ checkHtmlStringCoercion(children$jscomp$2);
1852+ value$jscomp$0 = "" + children$jscomp$2;
21931853 }
2194−
2195− break;
2196−
2197− case 'dangerouslySetInnerHTML':
2198− innerHTML = propValue;
2199− break;
2200− // eslint-disable-next-line-no-fallthrough
2201−
2202− case 'value':
2203− value = propValue;
2204− // We intentionally fallthrough to also set the attribute on the node.
2205− // eslint-disable-next-line-no-fallthrough
2206−
2207− default:
2208− pushAttribute(target, responseState, propKey, propValue);
2209− break;
2210− }
2211− }
2212− }
2213−
2214− if (selectedValue != null) {
2215− var stringValue;
2216−
2217− if (value !== null) {
2218− {
2219− checkAttributeStringCoercion(value, 'value');
2220− }
2221−
2222− stringValue = '' + value;
2223− } else {
2224− {
2225− if (innerHTML !== null) {
2226− if (!didWarnInvalidOptionInnerHTML) {
2227− didWarnInvalidOptionInnerHTML = true;
2228−
2229− error('Pass a `value` prop if you set dangerouslyInnerHTML so React knows ' + 'which value should be selected.');
1854+ "string" === typeof value$jscomp$0 &&
1855+ "\n" === value$jscomp$0[0] &&
1856+ target$jscomp$0.push(leadingNewline);
1857+ null !== value$jscomp$0 &&
1858+ (checkAttributeStringCoercion(value$jscomp$0, "value"),
1859+ target$jscomp$0.push(escapeTextForBrowser("" + value$jscomp$0)));
1860+ return null;
1861+ case "input":
1862+ checkControlledValueProps("input", props);
1863+ target$jscomp$0.push(startChunkForTag("input"));
1864+ var name = null,
1865+ formAction = null,
1866+ formEncType = null,
1867+ formMethod = null,
1868+ formTarget = null,
1869+ value$jscomp$1 = null,
1870+ defaultValue$jscomp$0 = null,
1871+ checked = null,
1872+ defaultChecked = null,
1873+ propKey$jscomp$3;
1874+ for (propKey$jscomp$3 in props)
1875+ if (hasOwnProperty.call(props, propKey$jscomp$3)) {
1876+ var propValue$jscomp$3 = props[propKey$jscomp$3];
1877+ if (null != propValue$jscomp$3)
1878+ switch (propKey$jscomp$3) {
1879+ case "children":
1880+ case "dangerouslySetInnerHTML":
1881+ throw Error(
1882+ "input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
1883+ );
1884+ case "name":
1885+ name = propValue$jscomp$3;
1886+ break;
1887+ case "formAction":
1888+ formAction = propValue$jscomp$3;
1889+ break;
1890+ case "formEncType":
1891+ formEncType = propValue$jscomp$3;
1892+ break;
1893+ case "formMethod":
1894+ formMethod = propValue$jscomp$3;
1895+ break;
1896+ case "formTarget":
1897+ formTarget = propValue$jscomp$3;
1898+ break;
1899+ case "defaultChecked":
1900+ defaultChecked = propValue$jscomp$3;
1901+ break;
1902+ case "defaultValue":
1903+ defaultValue$jscomp$0 = propValue$jscomp$3;
1904+ break;
1905+ case "checked":
1906+ checked = propValue$jscomp$3;
1907+ break;
1908+ case "value":
1909+ value$jscomp$1 = propValue$jscomp$3;
1910+ break;
1911+ default:
1912+ pushAttribute(
1913+ target$jscomp$0,
1914+ propKey$jscomp$3,
1915+ propValue$jscomp$3
1916+ );
1917+ }
1918+ }
1919+ null === formAction ||
1920+ "image" === props.type ||
1921+ "submit" === props.type ||
1922+ didWarnFormActionType ||
1923+ ((didWarnFormActionType = !0),
1924+ console.error(
1925+ 'An input can only specify a formAction along with type="submit" or type="image".'
1926+ ));
1927+ var formData = pushFormActionAttribute(
1928+ target$jscomp$0,
1929+ resumableState,
1930+ renderState,
1931+ formAction,
1932+ formEncType,
1933+ formMethod,
1934+ formTarget,
1935+ name
1936+ );
1937+ null === checked ||
1938+ null === defaultChecked ||
1939+ didWarnDefaultChecked ||
1940+ (console.error(
1941+ "%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://react.dev/link/controlled-components",
1942+ "A component",
1943+ props.type
1944+ ),
1945+ (didWarnDefaultChecked = !0));
1946+ null === value$jscomp$1 ||
1947+ null === defaultValue$jscomp$0 ||
1948+ didWarnDefaultInputValue ||
1949+ (console.error(
1950+ "%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://react.dev/link/controlled-components",
1951+ "A component",
1952+ props.type
1953+ ),
1954+ (didWarnDefaultInputValue = !0));
1955+ null !== checked
1956+ ? pushBooleanAttribute(target$jscomp$0, "checked", checked)
1957+ : null !== defaultChecked &&
1958+ pushBooleanAttribute(target$jscomp$0, "checked", defaultChecked);
1959+ null !== value$jscomp$1
1960+ ? pushAttribute(target$jscomp$0, "value", value$jscomp$1)
1961+ : null !== defaultValue$jscomp$0 &&
1962+ pushAttribute(target$jscomp$0, "value", defaultValue$jscomp$0);
1963+ target$jscomp$0.push(endOfStartTagSelfClosing);
1964+ null != formData &&
1965+ formData.forEach(pushAdditionalFormField, target$jscomp$0);
1966+ return null;
1967+ case "button":
1968+ target$jscomp$0.push(startChunkForTag("button"));
1969+ var children$jscomp$3 = null,
1970+ innerHTML$jscomp$2 = null,
1971+ name$jscomp$0 = null,
1972+ formAction$jscomp$0 = null,
1973+ formEncType$jscomp$0 = null,
1974+ formMethod$jscomp$0 = null,
1975+ formTarget$jscomp$0 = null,
1976+ propKey$jscomp$4;
1977+ for (propKey$jscomp$4 in props)
1978+ if (hasOwnProperty.call(props, propKey$jscomp$4)) {
1979+ var propValue$jscomp$4 = props[propKey$jscomp$4];
1980+ if (null != propValue$jscomp$4)
1981+ switch (propKey$jscomp$4) {
1982+ case "children":
1983+ children$jscomp$3 = propValue$jscomp$4;
1984+ break;
1985+ case "dangerouslySetInnerHTML":
1986+ innerHTML$jscomp$2 = propValue$jscomp$4;
1987+ break;
1988+ case "name":
1989+ name$jscomp$0 = propValue$jscomp$4;
1990+ break;
1991+ case "formAction":
1992+ formAction$jscomp$0 = propValue$jscomp$4;
1993+ break;
1994+ case "formEncType":
1995+ formEncType$jscomp$0 = propValue$jscomp$4;
1996+ break;
1997+ case "formMethod":
1998+ formMethod$jscomp$0 = propValue$jscomp$4;
1999+ break;
2000+ case "formTarget":
2001+ formTarget$jscomp$0 = propValue$jscomp$4;
2002+ break;
2003+ default:
2004+ pushAttribute(
2005+ target$jscomp$0,
2006+ propKey$jscomp$4,
2007+ propValue$jscomp$4
2008+ );
2009+ }
2010+ }
2011+ null === formAction$jscomp$0 ||
2012+ null == props.type ||
2013+ "submit" === props.type ||
2014+ didWarnFormActionType ||
2015+ ((didWarnFormActionType = !0),
2016+ console.error(
2017+ 'A button can only specify a formAction along with type="submit" or no type.'
2018+ ));
2019+ var formData$jscomp$0 = pushFormActionAttribute(
2020+ target$jscomp$0,
2021+ resumableState,
2022+ renderState,
2023+ formAction$jscomp$0,
2024+ formEncType$jscomp$0,
2025+ formMethod$jscomp$0,
2026+ formTarget$jscomp$0,
2027+ name$jscomp$0
2028+ );
2029+ target$jscomp$0.push(endOfStartTag);
2030+ null != formData$jscomp$0 &&
2031+ formData$jscomp$0.forEach(pushAdditionalFormField, target$jscomp$0);
2032+ pushInnerHTML(target$jscomp$0, innerHTML$jscomp$2, children$jscomp$3);
2033+ if ("string" === typeof children$jscomp$3) {
2034+ target$jscomp$0.push(escapeTextForBrowser(children$jscomp$3));
2035+ var JSCompiler_inline_result$jscomp$1 = null;
2036+ } else JSCompiler_inline_result$jscomp$1 = children$jscomp$3;
2037+ return JSCompiler_inline_result$jscomp$1;
2038+ case "form":
2039+ target$jscomp$0.push(startChunkForTag("form"));
2040+ var children$jscomp$4 = null,
2041+ innerHTML$jscomp$3 = null,
2042+ formAction$jscomp$1 = null,
2043+ formEncType$jscomp$1 = null,
2044+ formMethod$jscomp$1 = null,
2045+ formTarget$jscomp$1 = null,
2046+ propKey$jscomp$5;
2047+ for (propKey$jscomp$5 in props)
2048+ if (hasOwnProperty.call(props, propKey$jscomp$5)) {
2049+ var propValue$jscomp$5 = props[propKey$jscomp$5];
2050+ if (null != propValue$jscomp$5)
2051+ switch (propKey$jscomp$5) {
2052+ case "children":
2053+ children$jscomp$4 = propValue$jscomp$5;
2054+ break;
2055+ case "dangerouslySetInnerHTML":
2056+ innerHTML$jscomp$3 = propValue$jscomp$5;
2057+ break;
2058+ case "action":
2059+ formAction$jscomp$1 = propValue$jscomp$5;
2060+ break;
2061+ case "encType":
2062+ formEncType$jscomp$1 = propValue$jscomp$5;
2063+ break;
2064+ case "method":
2065+ formMethod$jscomp$1 = propValue$jscomp$5;
2066+ break;
2067+ case "target":
2068+ formTarget$jscomp$1 = propValue$jscomp$5;
2069+ break;
2070+ default:
2071+ pushAttribute(
2072+ target$jscomp$0,
2073+ propKey$jscomp$5,
2074+ propValue$jscomp$5
2075+ );
2076+ }
2077+ }
2078+ var formData$jscomp$1 = null,
2079+ formActionName = null;
2080+ if ("function" === typeof formAction$jscomp$1) {
2081+ (null === formEncType$jscomp$1 && null === formMethod$jscomp$1) ||
2082+ didWarnFormActionMethod ||
2083+ ((didWarnFormActionMethod = !0),
2084+ console.error(
2085+ "Cannot specify a encType or method for a form that specifies a function as the action. React provides those automatically. They will get overridden."
2086+ ));
2087+ null === formTarget$jscomp$1 ||
2088+ didWarnFormActionTarget ||
2089+ ((didWarnFormActionTarget = !0),
2090+ console.error(
2091+ "Cannot specify a target for a form that specifies a function as the action. The function will always be executed in the same window."
2092+ ));
2093+ var customFields = getCustomFormFields(
2094+ resumableState,
2095+ formAction$jscomp$1
2096+ );
2097+ null !== customFields
2098+ ? ((formAction$jscomp$1 = customFields.action || ""),
2099+ (formEncType$jscomp$1 = customFields.encType),
2100+ (formMethod$jscomp$1 = customFields.method),
2101+ (formTarget$jscomp$1 = customFields.target),
2102+ (formData$jscomp$1 = customFields.data),
2103+ (formActionName = customFields.name))
2104+ : (target$jscomp$0.push(
2105+ attributeSeparator,
2106+ "action",
2107+ attributeAssign,
2108+ actionJavaScriptURL,
2109+ attributeEnd
2110+ ),
2111+ (formTarget$jscomp$1 =
2112+ formMethod$jscomp$1 =
2113+ formEncType$jscomp$1 =
2114+ formAction$jscomp$1 =
2115+ null),
2116+ injectFormReplayingRuntime(resumableState, renderState));
22302117 }
2231− }
2232− }
2233−
2234− stringValue = flattenOptionChildren(children);
2235− }
2236−
2237− if (isArray(selectedValue)) {
2238− // multiple
2239− for (var i = 0; i < selectedValue.length; i++) {
2240− {
2241− checkAttributeStringCoercion(selectedValue[i], 'value');
2242− }
2243−
2244− var v = '' + selectedValue[i];
2245−
2246− if (v === stringValue) {
2247− target.push(selectedMarkerAttribute);
2248− break;
2249− }
2250− }
2251− } else {
2252− {
2253− checkAttributeStringCoercion(selectedValue, 'select.value');
2254− }
2255−
2256− if ('' + selectedValue === stringValue) {
2257− target.push(selectedMarkerAttribute);
2258− }
2259− }
2260− } else if (selected) {
2261− target.push(selectedMarkerAttribute);
2262− }
2263−
2264− target.push(endOfStartTag);
2265− pushInnerHTML(target, innerHTML, children);
2266− return children;
2267−}
2268−
2269−function pushInput(target, props, responseState) {
2270− {
2271− checkControlledValueProps('input', props);
2272−
2273− if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnDefaultChecked) {
2274− 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', 'A component', props.type);
2275−
2276− didWarnDefaultChecked = true;
2277− }
2278−
2279− if (props.value !== undefined && props.defaultValue !== undefined && !didWarnDefaultInputValue) {
2280− 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', 'A component', props.type);
2281−
2282− didWarnDefaultInputValue = true;
2283− }
2284− }
2285−
2286− target.push(startChunkForTag('input'));
2287− var value = null;
2288− var defaultValue = null;
2289− var checked = null;
2290− var defaultChecked = null;
2291−
2292− for (var propKey in props) {
2293− if (hasOwnProperty.call(props, propKey)) {
2294− var propValue = props[propKey];
2295−
2296− if (propValue == null) {
2297− continue;
2298− }
2299−
2300− switch (propKey) {
2301− case 'children':
2302− case 'dangerouslySetInnerHTML':
2303− throw new Error('input' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
2304− // eslint-disable-next-line-no-fallthrough
2305−
2306− case 'defaultChecked':
2307− defaultChecked = propValue;
2308− break;
2309−
2310− case 'defaultValue':
2311− defaultValue = propValue;
2312− break;
2313−
2314− case 'checked':
2315− checked = propValue;
2316− break;
2317−
2318− case 'value':
2319− value = propValue;
2320− break;
2321−
2322− default:
2323− pushAttribute(target, responseState, propKey, propValue);
2324− break;
2325− }
2326− }
2327− }
2328−
2329− if (checked !== null) {
2330− pushAttribute(target, responseState, 'checked', checked);
2331− } else if (defaultChecked !== null) {
2332− pushAttribute(target, responseState, 'checked', defaultChecked);
2333− }
2334−
2335− if (value !== null) {
2336− pushAttribute(target, responseState, 'value', value);
2337− } else if (defaultValue !== null) {
2338− pushAttribute(target, responseState, 'value', defaultValue);
2339− }
2340−
2341− target.push(endOfStartTagSelfClosing);
2342− return null;
2343−}
2344−
2345−function pushStartTextArea(target, props, responseState) {
2346− {
2347− checkControlledValueProps('textarea', props);
2348−
2349− if (props.value !== undefined && props.defaultValue !== undefined && !didWarnDefaultTextareaValue) {
2350− error('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');
2351−
2352− didWarnDefaultTextareaValue = true;
2353− }
2354− }
2355−
2356− target.push(startChunkForTag('textarea'));
2357− var value = null;
2358− var defaultValue = null;
2359− var children = null;
2360−
2361− for (var propKey in props) {
2362− if (hasOwnProperty.call(props, propKey)) {
2363− var propValue = props[propKey];
2364−
2365− if (propValue == null) {
2366− continue;
2367− }
2368−
2369− switch (propKey) {
2370− case 'children':
2371− children = propValue;
2372− break;
2373−
2374− case 'value':
2375− value = propValue;
2376− break;
2377−
2378− case 'defaultValue':
2379− defaultValue = propValue;
2380− break;
2381−
2382− case 'dangerouslySetInnerHTML':
2383− throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
2384− // eslint-disable-next-line-no-fallthrough
2385−
2386− default:
2387− pushAttribute(target, responseState, propKey, propValue);
2388− break;
2389− }
2390− }
2391− }
2392−
2393− if (value === null && defaultValue !== null) {
2394− value = defaultValue;
2395− }
2396−
2397− target.push(endOfStartTag); // TODO (yungsters): Remove support for children content in <textarea>.
2398−
2399− if (children != null) {
2400− {
2401− error('Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.');
2402− }
2403−
2404− if (value != null) {
2405− throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
2406− }
2407−
2408− if (isArray(children)) {
2409− if (children.length > 1) {
2410− throw new Error('<textarea> can only have at most one child.');
2411− } // TODO: remove the coercion and the DEV check below because it will
2412− // always be overwritten by the coercion several lines below it. #22309
2413−
2414−
2415− {
2416− checkHtmlStringCoercion(children[0]);
2417− }
2418−
2419− value = '' + children[0];
2420− }
2421−
2422− {
2423− checkHtmlStringCoercion(children);
2424− }
2425−
2426− value = '' + children;
2427− }
2428−
2429− if (typeof value === 'string' && value[0] === '\n') {
2430− // text/html ignores the first character in these tags if it's a newline
2431− // Prefer to break application/xml over text/html (for now) by adding
2432− // a newline specifically to get eaten by the parser. (Alternately for
2433− // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
2434− // \r is normalized out by HTMLTextAreaElement#value.)
2435− // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
2436− // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
2437− // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
2438− // See: Parsing of "textarea" "listing" and "pre" elements
2439− // from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
2440− target.push(leadingNewline);
2441− } // ToString and push directly instead of recurse over children.
2442− // We don't really support complex children in the value anyway.
2443− // This also currently avoids a trailing comment node which breaks textarea.
2444−
2445−
2446− if (value !== null) {
2447− {
2448− checkAttributeStringCoercion(value, 'value');
2449− }
2450−
2451− target.push(stringToChunk(encodeHTMLTextNode('' + value)));
2452− }
2453−
2454− return null;
2455−}
2456−
2457−function pushSelfClosing(target, props, tag, responseState) {
2458− target.push(startChunkForTag(tag));
2459−
2460− for (var propKey in props) {
2461− if (hasOwnProperty.call(props, propKey)) {
2462− var propValue = props[propKey];
2463−
2464− if (propValue == null) {
2465− continue;
2466− }
2467−
2468− switch (propKey) {
2469− case 'children':
2470− case 'dangerouslySetInnerHTML':
2471− throw new Error(tag + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
2472− // eslint-disable-next-line-no-fallthrough
2473−
2474− default:
2475− pushAttribute(target, responseState, propKey, propValue);
2476− break;
2477− }
2478− }
2479− }
2480−
2481− target.push(endOfStartTagSelfClosing);
2482− return null;
2483−}
2484−
2485−function pushStartMenuItem(target, props, responseState) {
2486− target.push(startChunkForTag('menuitem'));
2487−
2488− for (var propKey in props) {
2489− if (hasOwnProperty.call(props, propKey)) {
2490− var propValue = props[propKey];
2491−
2492− if (propValue == null) {
2493− continue;
2494− }
2495−
2496− switch (propKey) {
2497− case 'children':
2498− case 'dangerouslySetInnerHTML':
2499− throw new Error('menuitems cannot have `children` nor `dangerouslySetInnerHTML`.');
2500− // eslint-disable-next-line-no-fallthrough
2501−
2502− default:
2503− pushAttribute(target, responseState, propKey, propValue);
2504− break;
2505− }
2506− }
2507− }
2508−
2509− target.push(endOfStartTag);
2510− return null;
2511−}
2512−
2513−function pushStartTitle(target, props, responseState) {
2514− target.push(startChunkForTag('title'));
2515− var children = null;
2516−
2517− for (var propKey in props) {
2518− if (hasOwnProperty.call(props, propKey)) {
2519− var propValue = props[propKey];
2520−
2521− if (propValue == null) {
2522− continue;
2523− }
2524−
2525− switch (propKey) {
2526− case 'children':
2527− children = propValue;
2528− break;
2529−
2530− case 'dangerouslySetInnerHTML':
2531− throw new Error('`dangerouslySetInnerHTML` does not make sense on <title>.');
2532− // eslint-disable-next-line-no-fallthrough
2533−
2534− default:
2535− pushAttribute(target, responseState, propKey, propValue);
2536− break;
2537− }
2538− }
2539− }
2540−
2541− target.push(endOfStartTag);
2542−
2543− {
2544− var child = Array.isArray(children) && children.length < 2 ? children[0] || null : children;
2545−
2546− if (Array.isArray(children) && children.length > 1) {
2547− error('A title element received an array with more than 1 element as children. ' + 'In browsers title Elements can only have Text Nodes as children. If ' + 'the children being rendered output more than a single text node in aggregate the browser ' + 'will display markup and comments as text in the title and hydration will likely fail and ' + 'fall back to client rendering');
2548− } else if (child != null && child.$$typeof != null) {
2549− error('A title element received a React element for children. ' + 'In the browser title Elements can only have Text Nodes as children. If ' + 'the children being rendered output more than a single text node in aggregate the browser ' + 'will display markup and comments as text in the title and hydration will likely fail and ' + 'fall back to client rendering');
2550− } else if (child != null && typeof child !== 'string' && typeof child !== 'number') {
2551− error('A title element received a value that was not a string or number for children. ' + 'In the browser title Elements can only have Text Nodes as children. If ' + 'the children being rendered output more than a single text node in aggregate the browser ' + 'will display markup and comments as text in the title and hydration will likely fail and ' + 'fall back to client rendering');
2552− }
2553− }
2554−
2555− return children;
2556−}
2557−
2558−function pushStartGenericElement(target, props, tag, responseState) {
2559− target.push(startChunkForTag(tag));
2560− var children = null;
2561− var innerHTML = null;
2562−
2563− for (var propKey in props) {
2564− if (hasOwnProperty.call(props, propKey)) {
2565− var propValue = props[propKey];
2566−
2567− if (propValue == null) {
2568− continue;
2569− }
2570−
2571− switch (propKey) {
2572− case 'children':
2573− children = propValue;
2574− break;
2575−
2576− case 'dangerouslySetInnerHTML':
2577− innerHTML = propValue;
2578− break;
2579−
2580− default:
2581− pushAttribute(target, responseState, propKey, propValue);
2582− break;
2583− }
2584− }
2585− }
2586−
2587− target.push(endOfStartTag);
2588− pushInnerHTML(target, innerHTML, children);
2589−
2590− if (typeof children === 'string') {
2591− // Special case children as a string to avoid the unnecessary comment.
2592− // TODO: Remove this special case after the general optimization is in place.
2593− target.push(stringToChunk(encodeHTMLTextNode(children)));
2594− return null;
2595− }
2596−
2597− return children;
2598−}
2599−
2600−function pushStartCustomElement(target, props, tag, responseState) {
2601− target.push(startChunkForTag(tag));
2602− var children = null;
2603− var innerHTML = null;
2604−
2605− for (var propKey in props) {
2606− if (hasOwnProperty.call(props, propKey)) {
2607− var propValue = props[propKey];
2608−
2609− if (propValue == null) {
2610− continue;
2611− }
2612−
2613− switch (propKey) {
2614− case 'children':
2615− children = propValue;
2616− break;
2617−
2618− case 'dangerouslySetInnerHTML':
2619− innerHTML = propValue;
2620− break;
2621−
2622− case 'style':
2623− pushStyle(target, responseState, propValue);
2624− break;
2625−
2626− case 'suppressContentEditableWarning':
2627− case 'suppressHydrationWarning':
2628− // Ignored. These are built-in to React on the client.
2629− break;
2630−
2631− default:
2632− if (isAttributeNameSafe(propKey) && typeof propValue !== 'function' && typeof propValue !== 'symbol') {
2633− target.push(attributeSeparator, stringToChunk(propKey), attributeAssign, stringToChunk(escapeTextForBrowser(propValue)), attributeEnd);
2634− }
2635−
2636− break;
2637− }
2638− }
2639− }
2640−
2641− target.push(endOfStartTag);
2642− pushInnerHTML(target, innerHTML, children);
2643− return children;
2644−}
2645−
2646−var leadingNewline = stringToPrecomputedChunk('\n');
2647−
2648−function pushStartPreformattedElement(target, props, tag, responseState) {
2649− target.push(startChunkForTag(tag));
2650− var children = null;
2651− var innerHTML = null;
2652−
2653− for (var propKey in props) {
2654− if (hasOwnProperty.call(props, propKey)) {
2655− var propValue = props[propKey];
2656−
2657− if (propValue == null) {
2658− continue;
2659− }
2660−
2661− switch (propKey) {
2662− case 'children':
2663− children = propValue;
2664− break;
2665−
2666− case 'dangerouslySetInnerHTML':
2667− innerHTML = propValue;
2668− break;
2669−
2670− default:
2671− pushAttribute(target, responseState, propKey, propValue);
2672− break;
2673− }
2674− }
2675− }
2676−
2677− target.push(endOfStartTag); // text/html ignores the first character in these tags if it's a newline
2678− // Prefer to break application/xml over text/html (for now) by adding
2679− // a newline specifically to get eaten by the parser. (Alternately for
2680− // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
2681− // \r is normalized out by HTMLTextAreaElement#value.)
2682− // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
2683− // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
2684− // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
2685− // See: Parsing of "textarea" "listing" and "pre" elements
2686− // from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
2687− // TODO: This doesn't deal with the case where the child is an array
2688− // or component that returns a string.
2689−
2690− if (innerHTML != null) {
2691− if (children != null) {
2692− throw new Error('Can only set one of `children` or `props.dangerouslySetInnerHTML`.');
2693− }
2694−
2695− if (typeof innerHTML !== 'object' || !('__html' in innerHTML)) {
2696− throw new Error('`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://reactjs.org/link/dangerously-set-inner-html ' + 'for more information.');
2697− }
2698−
2699− var html = innerHTML.__html;
2700−
2701− if (html !== null && html !== undefined) {
2702− if (typeof html === 'string' && html.length > 0 && html[0] === '\n') {
2703− target.push(leadingNewline, stringToChunk(html));
2704− } else {
2705− {
2706− checkHtmlStringCoercion(html);
2707− }
2708−
2709− target.push(stringToChunk('' + html));
2710− }
2711− }
2712− }
2713−
2714− if (typeof children === 'string' && children[0] === '\n') {
2715− target.push(leadingNewline);
2716− }
2717−
2718− return children;
2719−} // We accept any tag to be rendered but since this gets injected into arbitrary
2720−// HTML, we want to make sure that it's a safe tag.
2721−// http://www.w3.org/TR/REC-xml/#NT-Name
2722−
2723−
2724−var VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
2725−
2726−var validatedTagCache = new Map();
2727−
2728−function startChunkForTag(tag) {
2729− var tagStartChunk = validatedTagCache.get(tag);
2730−
2731− if (tagStartChunk === undefined) {
2732− if (!VALID_TAG_REGEX.test(tag)) {
2733− throw new Error("Invalid tag: " + tag);
2734− }
2735−
2736− tagStartChunk = stringToPrecomputedChunk('<' + tag);
2737− validatedTagCache.set(tag, tagStartChunk);
2738− }
2739−
2740− return tagStartChunk;
2741−}
2742−
2743−var DOCTYPE = stringToPrecomputedChunk('<!DOCTYPE html>');
2744−function pushStartInstance(target, type, props, responseState, formatContext) {
2745− {
2746− validateProperties(type, props);
2747− validateProperties$1(type, props);
2748− validateProperties$2(type, props, null);
2749−
2750− if (!props.suppressContentEditableWarning && props.contentEditable && props.children != null) {
2751− 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.');
2752− }
2753−
2754− if (formatContext.insertionMode !== SVG_MODE && formatContext.insertionMode !== MATHML_MODE) {
2755− if (type.indexOf('-') === -1 && typeof props.is !== 'string' && type.toLowerCase() !== type) {
2756− error('<%s /> is using incorrect casing. ' + 'Use PascalCase for React components, ' + 'or lowercase for HTML elements.', type);
2757− }
2758− }
2759− }
2760−
2761− switch (type) {
2762− // Special tags
2763− case 'select':
2764− return pushStartSelect(target, props, responseState);
2765−
2766− case 'option':
2767− return pushStartOption(target, props, responseState, formatContext);
2768−
2769− case 'textarea':
2770− return pushStartTextArea(target, props, responseState);
2771−
2772− case 'input':
2773− return pushInput(target, props, responseState);
2774−
2775− case 'menuitem':
2776− return pushStartMenuItem(target, props, responseState);
2777−
2778− case 'title':
2779− return pushStartTitle(target, props, responseState);
2780− // Newline eating tags
2781−
2782− case 'listing':
2783− case 'pre':
2784− {
2785− return pushStartPreformattedElement(target, props, type, responseState);
2786− }
2787− // Omitted close tags
2788−
2789− case 'area':
2790− case 'base':
2791− case 'br':
2792− case 'col':
2793− case 'embed':
2794− case 'hr':
2795− case 'img':
2796− case 'keygen':
2797− case 'link':
2798− case 'meta':
2799− case 'param':
2800− case 'source':
2801− case 'track':
2802− case 'wbr':
2803− {
2804− return pushSelfClosing(target, props, type, responseState);
2805− }
2806− // These are reserved SVG and MathML elements, that are never custom elements.
2807− // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
2808−
2809− case 'annotation-xml':
2810− case 'color-profile':
2811− case 'font-face':
2812− case 'font-face-src':
2813− case 'font-face-uri':
2814− case 'font-face-format':
2815− case 'font-face-name':
2816− case 'missing-glyph':
2817− {
2818− return pushStartGenericElement(target, props, type, responseState);
2819− }
2820−
2821− case 'html':
2822− {
2823− if (formatContext.insertionMode === ROOT_HTML_MODE) {
2824− // If we're rendering the html tag and we're at the root (i.e. not in foreignObject)
2825− // then we also emit the DOCTYPE as part of the root content as a convenience for
2826− // rendering the whole document.
2827− target.push(DOCTYPE);
2828− }
2829−
2830− return pushStartGenericElement(target, props, type, responseState);
2831− }
2832−
2833− default:
2834− {
2835− if (type.indexOf('-') === -1 && typeof props.is !== 'string') {
2836− // Generic element
2837− return pushStartGenericElement(target, props, type, responseState);
2838− } else {
2839− // Custom element
2840− return pushStartCustomElement(target, props, type, responseState);
2841− }
2842− }
2843− }
2844−}
2845−var endTag1 = stringToPrecomputedChunk('</');
2846−var endTag2 = stringToPrecomputedChunk('>');
2847−function pushEndInstance(target, type, props) {
2848− switch (type) {
2849− // Omitted close tags
2850− // TODO: Instead of repeating this switch we could try to pass a flag from above.
2851− // That would require returning a tuple. Which might be ok if it gets inlined.
2852− case 'area':
2853− case 'base':
2854− case 'br':
2855− case 'col':
2856− case 'embed':
2857− case 'hr':
2858− case 'img':
2859− case 'input':
2860− case 'keygen':
2861− case 'link':
2862− case 'meta':
2863− case 'param':
2864− case 'source':
2865− case 'track':
2866− case 'wbr':
2867− {
2868− // No close tag needed.
2869− break;
2870− }
2871−
2872− default:
2873− {
2874− target.push(endTag1, stringToChunk(type), endTag2);
2875− }
2876− }
2877−}
2878−function writeCompletedRoot(destination, responseState) {
2879− var bootstrapChunks = responseState.bootstrapChunks;
2880− var i = 0;
2881−
2882− for (; i < bootstrapChunks.length - 1; i++) {
2883− writeChunk(destination, bootstrapChunks[i]);
2884− }
2885−
2886− if (i < bootstrapChunks.length) {
2887− return writeChunkAndReturn(destination, bootstrapChunks[i]);
2888− }
2889−
2890− return true;
2891−} // Structural Nodes
2892−// A placeholder is a node inside a hidden partial tree that can be filled in later, but before
2893−// display. It's never visible to users. We use the template tag because it can be used in every
2894−// type of parent. <script> tags also work in every other tag except <colgroup>.
2895−
2896−var placeholder1 = stringToPrecomputedChunk('<template id="');
2897−var placeholder2 = stringToPrecomputedChunk('"></template>');
2898−function writePlaceholder(destination, responseState, id) {
2899− writeChunk(destination, placeholder1);
2900− writeChunk(destination, responseState.placeholderPrefix);
2901− var formattedID = stringToChunk(id.toString(16));
2902− writeChunk(destination, formattedID);
2903− return writeChunkAndReturn(destination, placeholder2);
2904−} // Suspense boundaries are encoded as comments.
2905−
2906−var startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
2907−var startPendingSuspenseBoundary1 = stringToPrecomputedChunk('<!--$?--><template id="');
2908−var startPendingSuspenseBoundary2 = stringToPrecomputedChunk('"></template>');
2909−var startClientRenderedSuspenseBoundary = stringToPrecomputedChunk('<!--$!-->');
2910−var endSuspenseBoundary = stringToPrecomputedChunk('<!--/$-->');
2911−var clientRenderedSuspenseBoundaryError1 = stringToPrecomputedChunk('<template');
2912−var clientRenderedSuspenseBoundaryErrorAttrInterstitial = stringToPrecomputedChunk('"');
2913−var clientRenderedSuspenseBoundaryError1A = stringToPrecomputedChunk(' data-dgst="');
2914−var clientRenderedSuspenseBoundaryError1B = stringToPrecomputedChunk(' data-msg="');
2915−var clientRenderedSuspenseBoundaryError1C = stringToPrecomputedChunk(' data-stck="');
2916−var clientRenderedSuspenseBoundaryError2 = stringToPrecomputedChunk('></template>');
2917−function writeStartCompletedSuspenseBoundary(destination, responseState) {
2918− return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
2919−}
2920−function writeStartPendingSuspenseBoundary(destination, responseState, id) {
2921− writeChunk(destination, startPendingSuspenseBoundary1);
2922−
2923− if (id === null) {
2924− throw new Error('An ID must have been assigned before we can complete the boundary.');
2925− }
2926−
2927− writeChunk(destination, id);
2928− return writeChunkAndReturn(destination, startPendingSuspenseBoundary2);
2929−}
2930−function writeStartClientRenderedSuspenseBoundary(destination, responseState, errorDigest, errorMesssage, errorComponentStack) {
2931− var result;
2932− result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
2933− writeChunk(destination, clientRenderedSuspenseBoundaryError1);
2934−
2935− if (errorDigest) {
2936− writeChunk(destination, clientRenderedSuspenseBoundaryError1A);
2937− writeChunk(destination, stringToChunk(escapeTextForBrowser(errorDigest)));
2938− writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
2939− }
2940−
2941− {
2942− if (errorMesssage) {
2943− writeChunk(destination, clientRenderedSuspenseBoundaryError1B);
2944− writeChunk(destination, stringToChunk(escapeTextForBrowser(errorMesssage)));
2945− writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
2946− }
2947−
2948− if (errorComponentStack) {
2949− writeChunk(destination, clientRenderedSuspenseBoundaryError1C);
2950− writeChunk(destination, stringToChunk(escapeTextForBrowser(errorComponentStack)));
2951− writeChunk(destination, clientRenderedSuspenseBoundaryErrorAttrInterstitial);
2952− }
2953− }
2954−
2955− result = writeChunkAndReturn(destination, clientRenderedSuspenseBoundaryError2);
2956− return result;
2957−}
2958−function writeEndCompletedSuspenseBoundary(destination, responseState) {
2959− return writeChunkAndReturn(destination, endSuspenseBoundary);
2960−}
2961−function writeEndPendingSuspenseBoundary(destination, responseState) {
2962− return writeChunkAndReturn(destination, endSuspenseBoundary);
2963−}
2964−function writeEndClientRenderedSuspenseBoundary(destination, responseState) {
2965− return writeChunkAndReturn(destination, endSuspenseBoundary);
2966−}
2967−var startSegmentHTML = stringToPrecomputedChunk('<div hidden id="');
2968−var startSegmentHTML2 = stringToPrecomputedChunk('">');
2969−var endSegmentHTML = stringToPrecomputedChunk('</div>');
2970−var startSegmentSVG = stringToPrecomputedChunk('<svg aria-hidden="true" style="display:none" id="');
2971−var startSegmentSVG2 = stringToPrecomputedChunk('">');
2972−var endSegmentSVG = stringToPrecomputedChunk('</svg>');
2973−var startSegmentMathML = stringToPrecomputedChunk('<math aria-hidden="true" style="display:none" id="');
2974−var startSegmentMathML2 = stringToPrecomputedChunk('">');
2975−var endSegmentMathML = stringToPrecomputedChunk('</math>');
2976−var startSegmentTable = stringToPrecomputedChunk('<table hidden id="');
2977−var startSegmentTable2 = stringToPrecomputedChunk('">');
2978−var endSegmentTable = stringToPrecomputedChunk('</table>');
2979−var startSegmentTableBody = stringToPrecomputedChunk('<table hidden><tbody id="');
2980−var startSegmentTableBody2 = stringToPrecomputedChunk('">');
2981−var endSegmentTableBody = stringToPrecomputedChunk('</tbody></table>');
2982−var startSegmentTableRow = stringToPrecomputedChunk('<table hidden><tr id="');
2983−var startSegmentTableRow2 = stringToPrecomputedChunk('">');
2984−var endSegmentTableRow = stringToPrecomputedChunk('</tr></table>');
2985−var startSegmentColGroup = stringToPrecomputedChunk('<table hidden><colgroup id="');
2986−var startSegmentColGroup2 = stringToPrecomputedChunk('">');
2987−var endSegmentColGroup = stringToPrecomputedChunk('</colgroup></table>');
2988−function writeStartSegment(destination, responseState, formatContext, id) {
2989− switch (formatContext.insertionMode) {
2990− case ROOT_HTML_MODE:
2991− case HTML_MODE:
2992− {
2993− writeChunk(destination, startSegmentHTML);
2994− writeChunk(destination, responseState.segmentPrefix);
2995− writeChunk(destination, stringToChunk(id.toString(16)));
2996− return writeChunkAndReturn(destination, startSegmentHTML2);
2997− }
2998−
2999− case SVG_MODE:
3000− {
3001− writeChunk(destination, startSegmentSVG);
3002− writeChunk(destination, responseState.segmentPrefix);
3003− writeChunk(destination, stringToChunk(id.toString(16)));
3004− return writeChunkAndReturn(destination, startSegmentSVG2);
3005− }
3006−
3007− case MATHML_MODE:
3008− {
3009− writeChunk(destination, startSegmentMathML);
3010− writeChunk(destination, responseState.segmentPrefix);
3011− writeChunk(destination, stringToChunk(id.toString(16)));
3012− return writeChunkAndReturn(destination, startSegmentMathML2);
3013− }
3014−
3015− case HTML_TABLE_MODE:
3016− {
3017− writeChunk(destination, startSegmentTable);
3018− writeChunk(destination, responseState.segmentPrefix);
3019− writeChunk(destination, stringToChunk(id.toString(16)));
3020− return writeChunkAndReturn(destination, startSegmentTable2);
3021− }
3022− // TODO: For the rest of these, there will be extra wrapper nodes that never
3023− // get deleted from the document. We need to delete the table too as part
3024− // of the injected scripts. They are invisible though so it's not too terrible
3025− // and it's kind of an edge case to suspend in a table. Totally supported though.
3026−
3027− case HTML_TABLE_BODY_MODE:
3028− {
3029− writeChunk(destination, startSegmentTableBody);
3030− writeChunk(destination, responseState.segmentPrefix);
3031− writeChunk(destination, stringToChunk(id.toString(16)));
3032− return writeChunkAndReturn(destination, startSegmentTableBody2);
3033− }
3034−
3035− case HTML_TABLE_ROW_MODE:
3036− {
3037− writeChunk(destination, startSegmentTableRow);
3038− writeChunk(destination, responseState.segmentPrefix);
3039− writeChunk(destination, stringToChunk(id.toString(16)));
3040− return writeChunkAndReturn(destination, startSegmentTableRow2);
3041− }
3042−
3043− case HTML_COLGROUP_MODE:
3044− {
3045− writeChunk(destination, startSegmentColGroup);
3046− writeChunk(destination, responseState.segmentPrefix);
3047− writeChunk(destination, stringToChunk(id.toString(16)));
3048− return writeChunkAndReturn(destination, startSegmentColGroup2);
3049− }
3050−
3051− default:
3052− {
3053− throw new Error('Unknown insertion mode. This is a bug in React.');
3054− }
3055− }
3056−}
3057−function writeEndSegment(destination, formatContext) {
3058− switch (formatContext.insertionMode) {
3059− case ROOT_HTML_MODE:
3060− case HTML_MODE:
3061− {
3062− return writeChunkAndReturn(destination, endSegmentHTML);
3063− }
3064−
3065− case SVG_MODE:
3066− {
3067− return writeChunkAndReturn(destination, endSegmentSVG);
3068− }
3069−
3070− case MATHML_MODE:
3071− {
3072− return writeChunkAndReturn(destination, endSegmentMathML);
3073− }
3074−
3075− case HTML_TABLE_MODE:
3076− {
3077− return writeChunkAndReturn(destination, endSegmentTable);
3078− }
3079−
3080− case HTML_TABLE_BODY_MODE:
3081− {
3082− return writeChunkAndReturn(destination, endSegmentTableBody);
3083− }
3084−
3085− case HTML_TABLE_ROW_MODE:
3086− {
3087− return writeChunkAndReturn(destination, endSegmentTableRow);
3088− }
3089−
3090− case HTML_COLGROUP_MODE:
3091− {
3092− return writeChunkAndReturn(destination, endSegmentColGroup);
3093− }
3094−
3095− default:
3096− {
3097− throw new Error('Unknown insertion mode. This is a bug in React.');
3098− }
3099− }
3100−} // Instruction Set
3101−// The following code is the source scripts that we then minify and inline below,
3102−// with renamed function names that we hope don't collide:
3103−// const COMMENT_NODE = 8;
3104−// const SUSPENSE_START_DATA = '$';
3105−// const SUSPENSE_END_DATA = '/$';
3106−// const SUSPENSE_PENDING_START_DATA = '$?';
3107−// const SUSPENSE_FALLBACK_START_DATA = '$!';
3108−//
3109−// function clientRenderBoundary(suspenseBoundaryID, errorDigest, errorMsg, errorComponentStack) {
3110−// // Find the fallback's first element.
3111−// const suspenseIdNode = document.getElementById(suspenseBoundaryID);
3112−// if (!suspenseIdNode) {
3113−// // The user must have already navigated away from this tree.
3114−// // E.g. because the parent was hydrated.
3115−// return;
3116−// }
3117−// // Find the boundary around the fallback. This is always the previous node.
3118−// const suspenseNode = suspenseIdNode.previousSibling;
3119−// // Tag it to be client rendered.
3120−// suspenseNode.data = SUSPENSE_FALLBACK_START_DATA;
3121−// // assign error metadata to first sibling
3122−// let dataset = suspenseIdNode.dataset;
3123−// if (errorDigest) dataset.dgst = errorDigest;
3124−// if (errorMsg) dataset.msg = errorMsg;
3125−// if (errorComponentStack) dataset.stck = errorComponentStack;
3126−// // Tell React to retry it if the parent already hydrated.
3127−// if (suspenseNode._reactRetry) {
3128−// suspenseNode._reactRetry();
3129−// }
3130−// }
3131−//
3132−// function completeBoundary(suspenseBoundaryID, contentID) {
3133−// // Find the fallback's first element.
3134−// const suspenseIdNode = document.getElementById(suspenseBoundaryID);
3135−// const contentNode = document.getElementById(contentID);
3136−// // We'll detach the content node so that regardless of what happens next we don't leave in the tree.
3137−// // This might also help by not causing recalcing each time we move a child from here to the target.
3138−// contentNode.parentNode.removeChild(contentNode);
3139−// if (!suspenseIdNode) {
3140−// // The user must have already navigated away from this tree.
3141−// // E.g. because the parent was hydrated. That's fine there's nothing to do
3142−// // but we have to make sure that we already deleted the container node.
3143−// return;
3144−// }
3145−// // Find the boundary around the fallback. This is always the previous node.
3146−// const suspenseNode = suspenseIdNode.previousSibling;
3147−//
3148−// // Clear all the existing children. This is complicated because
3149−// // there can be embedded Suspense boundaries in the fallback.
3150−// // This is similar to clearSuspenseBoundary in ReactDOMHostConfig.
3151−// // TODO: We could avoid this if we never emitted suspense boundaries in fallback trees.
3152−// // They never hydrate anyway. However, currently we support incrementally loading the fallback.
3153−// const parentInstance = suspenseNode.parentNode;
3154−// let node = suspenseNode.nextSibling;
3155−// let depth = 0;
3156−// do {
3157−// if (node && node.nodeType === COMMENT_NODE) {
3158−// const data = node.data;
3159−// if (data === SUSPENSE_END_DATA) {
3160−// if (depth === 0) {
3161−// break;
3162−// } else {
3163−// depth--;
3164−// }
3165−// } else if (
3166−// data === SUSPENSE_START_DATA ||
3167−// data === SUSPENSE_PENDING_START_DATA ||
3168−// data === SUSPENSE_FALLBACK_START_DATA
3169−// ) {
3170−// depth++;
3171−// }
3172−// }
3173−//
3174−// const nextNode = node.nextSibling;
3175−// parentInstance.removeChild(node);
3176−// node = nextNode;
3177−// } while (node);
3178−//
3179−// const endOfBoundary = node;
3180−//
3181−// // Insert all the children from the contentNode between the start and end of suspense boundary.
3182−// while (contentNode.firstChild) {
3183−// parentInstance.insertBefore(contentNode.firstChild, endOfBoundary);
3184−// }
3185−// suspenseNode.data = SUSPENSE_START_DATA;
3186−// if (suspenseNode._reactRetry) {
3187−// suspenseNode._reactRetry();
3188−// }
3189−// }
3190−//
3191−// function completeSegment(containerID, placeholderID) {
3192−// const segmentContainer = document.getElementById(containerID);
3193−// const placeholderNode = document.getElementById(placeholderID);
3194−// // We always expect both nodes to exist here because, while we might
3195−// // have navigated away from the main tree, we still expect the detached
3196−// // tree to exist.
3197−// segmentContainer.parentNode.removeChild(segmentContainer);
3198−// while (segmentContainer.firstChild) {
3199−// placeholderNode.parentNode.insertBefore(
3200−// segmentContainer.firstChild,
3201−// placeholderNode,
3202−// );
3203−// }
3204−// placeholderNode.parentNode.removeChild(placeholderNode);
3205−// }
3206−
3207−var completeSegmentFunction = 'function $RS(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)}';
3208−var completeBoundaryFunction = 'function $RC(a,b){a=document.getElementById(a);b=document.getElementById(b);b.parentNode.removeChild(b);if(a){a=a.previousSibling;var f=a.parentNode,c=a.nextSibling,e=0;do{if(c&&8===c.nodeType){var d=c.data;if("/$"===d)if(0===e)break;else e--;else"$"!==d&&"$?"!==d&&"$!"!==d||e++}d=c.nextSibling;f.removeChild(c);c=d}while(c);for(;b.firstChild;)f.insertBefore(b.firstChild,c);a.data="$";a._reactRetry&&a._reactRetry()}}';
3209−var clientRenderFunction = 'function $RX(b,c,d,e){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),b._reactRetry&&b._reactRetry())}';
3210−var completeSegmentScript1Full = stringToPrecomputedChunk(completeSegmentFunction + ';$RS("');
3211−var completeSegmentScript1Partial = stringToPrecomputedChunk('$RS("');
3212−var completeSegmentScript2 = stringToPrecomputedChunk('","');
3213−var completeSegmentScript3 = stringToPrecomputedChunk('")</script>');
3214−function writeCompletedSegmentInstruction(destination, responseState, contentSegmentID) {
3215− writeChunk(destination, responseState.startInlineScript);
3216−
3217− if (!responseState.sentCompleteSegmentFunction) {
3218− // The first time we write this, we'll need to include the full implementation.
3219− responseState.sentCompleteSegmentFunction = true;
3220− writeChunk(destination, completeSegmentScript1Full);
3221− } else {
3222− // Future calls can just reuse the same function.
3223− writeChunk(destination, completeSegmentScript1Partial);
3224− }
3225−
3226− writeChunk(destination, responseState.segmentPrefix);
3227− var formattedID = stringToChunk(contentSegmentID.toString(16));
3228− writeChunk(destination, formattedID);
3229− writeChunk(destination, completeSegmentScript2);
3230− writeChunk(destination, responseState.placeholderPrefix);
3231− writeChunk(destination, formattedID);
3232− return writeChunkAndReturn(destination, completeSegmentScript3);
3233−}
3234−var completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundaryFunction + ';$RC("');
3235−var completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
3236−var completeBoundaryScript2 = stringToPrecomputedChunk('","');
3237−var completeBoundaryScript3 = stringToPrecomputedChunk('")</script>');
3238−function writeCompletedBoundaryInstruction(destination, responseState, boundaryID, contentSegmentID) {
3239− writeChunk(destination, responseState.startInlineScript);
3240−
3241− if (!responseState.sentCompleteBoundaryFunction) {
3242− // The first time we write this, we'll need to include the full implementation.
3243− responseState.sentCompleteBoundaryFunction = true;
3244− writeChunk(destination, completeBoundaryScript1Full);
3245− } else {
3246− // Future calls can just reuse the same function.
3247− writeChunk(destination, completeBoundaryScript1Partial);
3248− }
3249−
3250− if (boundaryID === null) {
3251− throw new Error('An ID must have been assigned before we can complete the boundary.');
3252− }
3253−
3254− var formattedContentID = stringToChunk(contentSegmentID.toString(16));
3255− writeChunk(destination, boundaryID);
3256− writeChunk(destination, completeBoundaryScript2);
3257− writeChunk(destination, responseState.segmentPrefix);
3258− writeChunk(destination, formattedContentID);
3259− return writeChunkAndReturn(destination, completeBoundaryScript3);
3260−}
3261−var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderFunction + ';$RX("');
3262−var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
3263−var clientRenderScript1A = stringToPrecomputedChunk('"');
3264−var clientRenderScript2 = stringToPrecomputedChunk(')</script>');
3265−var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
3266−function writeClientRenderBoundaryInstruction(destination, responseState, boundaryID, errorDigest, errorMessage, errorComponentStack) {
3267− writeChunk(destination, responseState.startInlineScript);
3268−
3269− if (!responseState.sentClientRenderFunction) {
3270− // The first time we write this, we'll need to include the full implementation.
3271− responseState.sentClientRenderFunction = true;
3272− writeChunk(destination, clientRenderScript1Full);
3273− } else {
3274− // Future calls can just reuse the same function.
3275− writeChunk(destination, clientRenderScript1Partial);
3276− }
3277−
3278− if (boundaryID === null) {
3279− throw new Error('An ID must have been assigned before we can complete the boundary.');
3280− }
3281−
3282− writeChunk(destination, boundaryID);
3283− writeChunk(destination, clientRenderScript1A);
3284−
3285− if (errorDigest || errorMessage || errorComponentStack) {
3286− writeChunk(destination, clientRenderErrorScriptArgInterstitial);
3287− writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
3288− }
3289−
3290− if (errorMessage || errorComponentStack) {
3291− writeChunk(destination, clientRenderErrorScriptArgInterstitial);
3292− writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
3293− }
3294−
3295− if (errorComponentStack) {
3296− writeChunk(destination, clientRenderErrorScriptArgInterstitial);
3297− writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
3298− }
3299−
3300− return writeChunkAndReturn(destination, clientRenderScript2);
3301−}
3302−var regexForJSStringsInScripts = /[<\u2028\u2029]/g;
3303−
3304−function escapeJSStringsForInstructionScripts(input) {
3305− var escaped = JSON.stringify(input);
3306− return escaped.replace(regexForJSStringsInScripts, function (match) {
3307− switch (match) {
3308− // santizing breaking out of strings and script tags
3309− case '<':
3310− return "\\u003c";
3311−
3312− case "\u2028":
3313− return "\\u2028";
3314−
3315− case "\u2029":
3316− return "\\u2029";
3317−
3318− default:
3319− {
3320− // eslint-disable-next-line react-internal/prod-error-codes
3321− throw new Error('escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React');
3322− }
3323− }
3324− });
3325−}
3326−
3327−function createResponseState$1(generateStaticMarkup, identifierPrefix) {
3328− var responseState = createResponseState(identifierPrefix, undefined);
3329− return {
3330− // Keep this in sync with ReactDOMServerFormatConfig
3331− bootstrapChunks: responseState.bootstrapChunks,
3332− startInlineScript: responseState.startInlineScript,
3333− placeholderPrefix: responseState.placeholderPrefix,
3334− segmentPrefix: responseState.segmentPrefix,
3335− boundaryPrefix: responseState.boundaryPrefix,
3336− idPrefix: responseState.idPrefix,
3337− nextSuspenseID: responseState.nextSuspenseID,
3338− sentCompleteSegmentFunction: responseState.sentCompleteSegmentFunction,
3339− sentCompleteBoundaryFunction: responseState.sentCompleteBoundaryFunction,
3340− sentClientRenderFunction: responseState.sentClientRenderFunction,
3341− // This is an extra field for the legacy renderer
3342− generateStaticMarkup: generateStaticMarkup
3343− };
3344−}
3345−function createRootFormatContext() {
3346− return {
3347− insertionMode: HTML_MODE,
3348− // We skip the root mode because we don't want to emit the DOCTYPE in legacy mode.
3349− selectedValue: null
3350− };
3351−}
3352−function pushTextInstance$1(target, text, responseState, textEmbedded) {
3353− if (responseState.generateStaticMarkup) {
3354− target.push(stringToChunk(escapeTextForBrowser(text)));
3355− return false;
3356− } else {
3357− return pushTextInstance(target, text, responseState, textEmbedded);
3358− }
3359−}
3360−function pushSegmentFinale$1(target, responseState, lastPushedText, textEmbedded) {
3361− if (responseState.generateStaticMarkup) {
3362− return;
3363− } else {
3364− return pushSegmentFinale(target, responseState, lastPushedText, textEmbedded);
3365− }
3366−}
3367−function writeStartCompletedSuspenseBoundary$1(destination, responseState) {
3368− if (responseState.generateStaticMarkup) {
3369− // A completed boundary is done and doesn't need a representation in the HTML
3370− // if we're not going to be hydrating it.
3371− return true;
3372− }
3373−
3374− return writeStartCompletedSuspenseBoundary(destination);
3375−}
3376−function writeStartClientRenderedSuspenseBoundary$1(destination, responseState, // flushing these error arguments are not currently supported in this legacy streaming format.
3377−errorDigest, errorMessage, errorComponentStack) {
3378− if (responseState.generateStaticMarkup) {
3379− // A client rendered boundary is done and doesn't need a representation in the HTML
3380− // since we'll never hydrate it. This is arguably an error in static generation.
3381− return true;
3382− }
3383−
3384− return writeStartClientRenderedSuspenseBoundary(destination, responseState, errorDigest, errorMessage, errorComponentStack);
3385−}
3386−function writeEndCompletedSuspenseBoundary$1(destination, responseState) {
3387− if (responseState.generateStaticMarkup) {
3388− return true;
3389− }
3390−
3391− return writeEndCompletedSuspenseBoundary(destination);
3392−}
3393−function writeEndClientRenderedSuspenseBoundary$1(destination, responseState) {
3394− if (responseState.generateStaticMarkup) {
3395− return true;
3396− }
3397−
3398− return writeEndClientRenderedSuspenseBoundary(destination);
3399−}
3400−
3401−var assign = Object.assign;
3402−
3403−// ATTENTION
3404−// When adding new symbols to this file,
3405−// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
3406−// The Symbol used to tag the ReactElement-like types.
3407−var REACT_ELEMENT_TYPE = Symbol.for('react.element');
3408−var REACT_PORTAL_TYPE = Symbol.for('react.portal');
3409−var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
3410−var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
3411−var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
3412−var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
3413−var REACT_CONTEXT_TYPE = Symbol.for('react.context');
3414−var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
3415−var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
3416−var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
3417−var REACT_MEMO_TYPE = Symbol.for('react.memo');
3418−var REACT_LAZY_TYPE = Symbol.for('react.lazy');
3419−var REACT_SCOPE_TYPE = Symbol.for('react.scope');
3420−var REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
3421−var REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
3422−var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
3423−var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
3424−var FAUX_ITERATOR_SYMBOL = '@@iterator';
3425−function getIteratorFn(maybeIterable) {
3426− if (maybeIterable === null || typeof maybeIterable !== 'object') {
3427− return null;
3428− }
3429−
3430− var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
3431−
3432− if (typeof maybeIterator === 'function') {
3433− return maybeIterator;
3434− }
3435−
3436− return null;
3437−}
3438−
3439−function getWrappedName(outerType, innerType, wrapperName) {
3440− var displayName = outerType.displayName;
3441−
3442− if (displayName) {
3443− return displayName;
3444− }
3445−
3446− var functionName = innerType.displayName || innerType.name || '';
3447− return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
3448−} // Keep in sync with react-reconciler/getComponentNameFromFiber
3449−
3450−
3451−function getContextName(type) {
3452− return type.displayName || 'Context';
3453−} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
3454−
3455−
3456−function getComponentNameFromType(type) {
3457− if (type == null) {
3458− // Host root, text node or just invalid type.
3459− return null;
3460− }
3461−
3462− {
3463− if (typeof type.tag === 'number') {
3464− error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
3465− }
3466− }
3467−
3468− if (typeof type === 'function') {
3469− return type.displayName || type.name || null;
3470− }
3471−
3472− if (typeof type === 'string') {
3473− return type;
3474− }
3475−
3476− switch (type) {
3477− case REACT_FRAGMENT_TYPE:
3478− return 'Fragment';
3479−
3480− case REACT_PORTAL_TYPE:
3481− return 'Portal';
3482−
3483− case REACT_PROFILER_TYPE:
3484− return 'Profiler';
3485−
3486− case REACT_STRICT_MODE_TYPE:
3487− return 'StrictMode';
3488−
3489− case REACT_SUSPENSE_TYPE:
3490− return 'Suspense';
3491−
3492− case REACT_SUSPENSE_LIST_TYPE:
3493− return 'SuspenseList';
3494−
3495− }
3496−
3497− if (typeof type === 'object') {
3498− switch (type.$$typeof) {
3499− case REACT_CONTEXT_TYPE:
3500− var context = type;
3501− return getContextName(context) + '.Consumer';
3502−
3503− case REACT_PROVIDER_TYPE:
3504− var provider = type;
3505− return getContextName(provider._context) + '.Provider';
3506−
3507− case REACT_FORWARD_REF_TYPE:
3508− return getWrappedName(type, type.render, 'ForwardRef');
3509−
3510− case REACT_MEMO_TYPE:
3511− var outerName = type.displayName || null;
3512−
3513− if (outerName !== null) {
3514− return outerName;
3515− }
3516−
3517− return getComponentNameFromType(type.type) || 'Memo';
3518−
3519− case REACT_LAZY_TYPE:
3520− {
3521− var lazyComponent = type;
3522− var payload = lazyComponent._payload;
3523− var init = lazyComponent._init;
3524−
3525− try {
3526− return getComponentNameFromType(init(payload));
3527− } catch (x) {
3528− return null;
3529− }
3530− }
3531−
3532− // eslint-disable-next-line no-fallthrough
3533− }
3534− }
3535−
3536− return null;
3537−}
3538−
3539−// Helpers to patch console.logs to avoid logging during side-effect free
3540−// replaying on render function. This currently only patches the object
3541−// lazily which won't cover if the log function was extracted eagerly.
3542−// We could also eagerly patch the method.
3543−var disabledDepth = 0;
3544−var prevLog;
3545−var prevInfo;
3546−var prevWarn;
3547−var prevError;
3548−var prevGroup;
3549−var prevGroupCollapsed;
3550−var prevGroupEnd;
3551−
3552−function disabledLog() {}
3553−
3554−disabledLog.__reactDisabledLog = true;
3555−function disableLogs() {
3556− {
3557− if (disabledDepth === 0) {
3558− /* eslint-disable react-internal/no-production-logging */
3559− prevLog = console.log;
3560− prevInfo = console.info;
3561− prevWarn = console.warn;
3562− prevError = console.error;
3563− prevGroup = console.group;
3564− prevGroupCollapsed = console.groupCollapsed;
3565− prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
3566−
3567− var props = {
3568− configurable: true,
3569− enumerable: true,
3570− value: disabledLog,
3571− writable: true
3572− }; // $FlowFixMe Flow thinks console is immutable.
3573−
3574− Object.defineProperties(console, {
3575− info: props,
3576− log: props,
3577− warn: props,
3578− error: props,
3579− group: props,
3580− groupCollapsed: props,
3581− groupEnd: props
3582− });
3583− /* eslint-enable react-internal/no-production-logging */
3584− }
3585−
3586− disabledDepth++;
3587− }
3588−}
3589−function reenableLogs() {
3590− {
3591− disabledDepth--;
3592−
3593− if (disabledDepth === 0) {
3594− /* eslint-disable react-internal/no-production-logging */
3595− var props = {
3596− configurable: true,
3597− enumerable: true,
3598− writable: true
3599− }; // $FlowFixMe Flow thinks console is immutable.
3600−
3601− Object.defineProperties(console, {
3602− log: assign({}, props, {
3603− value: prevLog
3604− }),
3605− info: assign({}, props, {
3606− value: prevInfo
3607− }),
3608− warn: assign({}, props, {
3609− value: prevWarn
3610− }),
3611− error: assign({}, props, {
3612− value: prevError
3613− }),
3614− group: assign({}, props, {
3615− value: prevGroup
3616− }),
3617− groupCollapsed: assign({}, props, {
3618− value: prevGroupCollapsed
3619− }),
3620− groupEnd: assign({}, props, {
3621− value: prevGroupEnd
3622− })
3623− });
3624− /* eslint-enable react-internal/no-production-logging */
3625− }
3626−
3627− if (disabledDepth < 0) {
3628− error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
3629− }
3630− }
3631−}
3632−
3633−var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
3634−var prefix;
3635−function describeBuiltInComponentFrame(name, source, ownerFn) {
3636− {
3637− if (prefix === undefined) {
3638− // Extract the VM specific prefix used by each line.
3639− try {
3640− throw Error();
3641− } catch (x) {
3642− var match = x.stack.trim().match(/\n( *(at )?)/);
3643− prefix = match && match[1] || '';
3644− }
3645− } // We use the prefix to ensure our stacks line up with native stack frames.
3646−
3647−
3648− return '\n' + prefix + name;
3649− }
3650−}
3651−var reentry = false;
3652−var componentFrameCache;
3653−
3654−{
3655− var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
3656− componentFrameCache = new PossiblyWeakMap();
3657−}
3658−
3659−function describeNativeComponentFrame(fn, construct) {
3660− // If something asked for a stack inside a fake render, it should get ignored.
3661− if ( !fn || reentry) {
3662− return '';
3663− }
3664−
3665− {
3666− var frame = componentFrameCache.get(fn);
3667−
3668− if (frame !== undefined) {
3669− return frame;
3670− }
3671− }
3672−
3673− var control;
3674− reentry = true;
3675− var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
3676−
3677− Error.prepareStackTrace = undefined;
3678− var previousDispatcher;
3679−
3680− {
3681− previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
3682− // for warnings.
3683−
3684− ReactCurrentDispatcher.current = null;
3685− disableLogs();
3686− }
3687−
3688− try {
3689− // This should throw.
3690− if (construct) {
3691− // Something should be setting the props in the constructor.
3692− var Fake = function () {
3693− throw Error();
3694− }; // $FlowFixMe
3695−
3696−
3697− Object.defineProperty(Fake.prototype, 'props', {
3698− set: function () {
3699− // We use a throwing setter instead of frozen or non-writable props
3700− // because that won't throw in a non-strict mode function.
3701− throw Error();
3702− }
3703− });
3704−
3705− if (typeof Reflect === 'object' && Reflect.construct) {
3706− // We construct a different control for this case to include any extra
3707− // frames added by the construct call.
3708− try {
3709− Reflect.construct(Fake, []);
3710− } catch (x) {
3711− control = x;
3712− }
3713−
3714− Reflect.construct(fn, [], Fake);
3715− } else {
3716− try {
3717− Fake.call();
3718− } catch (x) {
3719− control = x;
3720− }
3721−
3722− fn.call(Fake.prototype);
3723− }
3724− } else {
3725− try {
3726− throw Error();
3727− } catch (x) {
3728− control = x;
3729− }
3730−
3731− fn();
3732− }
3733− } catch (sample) {
3734− // This is inlined manually because closure doesn't do it for us.
3735− if (sample && control && typeof sample.stack === 'string') {
3736− // This extracts the first frame from the sample that isn't also in the control.
3737− // Skipping one frame that we assume is the frame that calls the two.
3738− var sampleLines = sample.stack.split('\n');
3739− var controlLines = control.stack.split('\n');
3740− var s = sampleLines.length - 1;
3741− var c = controlLines.length - 1;
3742−
3743− while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
3744− // We expect at least one stack frame to be shared.
3745− // Typically this will be the root most one. However, stack frames may be
3746− // cut off due to maximum stack limits. In this case, one maybe cut off
3747− // earlier than the other. We assume that the sample is longer or the same
3748− // and there for cut off earlier. So we should find the root most frame in
3749− // the sample somewhere in the control.
3750− c--;
3751− }
3752−
3753− for (; s >= 1 && c >= 0; s--, c--) {
3754− // Next we find the first one that isn't the same which should be the
3755− // frame that called our sample function and the control.
3756− if (sampleLines[s] !== controlLines[c]) {
3757− // In V8, the first line is describing the message but other VMs don't.
3758− // If we're about to return the first line, and the control is also on the same
3759− // line, that's a pretty good indicator that our sample threw at same line as
3760− // the control. I.e. before we entered the sample frame. So we ignore this result.
3761− // This can happen if you passed a class to function component, or non-function.
3762− if (s !== 1 || c !== 1) {
3763− do {
3764− s--;
3765− c--; // We may still have similar intermediate frames from the construct call.
3766− // The next one that isn't the same should be our match though.
3767−
3768− if (c < 0 || sampleLines[s] !== controlLines[c]) {
3769− // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
3770− var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
3771− // but we have a user-provided "displayName"
3772− // splice it in to make the stack more readable.
3773−
3774−
3775− if (fn.displayName && _frame.includes('<anonymous>')) {
3776− _frame = _frame.replace('<anonymous>', fn.displayName);
3777− }
3778−
3779− {
3780− if (typeof fn === 'function') {
3781− componentFrameCache.set(fn, _frame);
3782− }
3783− } // Return the line we found.
3784−
3785−
3786− return _frame;
3787− }
3788− } while (s >= 1 && c >= 0);
3789− }
3790−
3791− break;
3792− }
3793− }
3794− }
3795− } finally {
3796− reentry = false;
3797−
3798− {
3799− ReactCurrentDispatcher.current = previousDispatcher;
3800− reenableLogs();
3801− }
3802−
3803− Error.prepareStackTrace = previousPrepareStackTrace;
3804− } // Fallback to just using the name if we couldn't make it throw.
3805−
3806−
3807− var name = fn ? fn.displayName || fn.name : '';
3808− var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
3809−
3810− {
3811− if (typeof fn === 'function') {
3812− componentFrameCache.set(fn, syntheticFrame);
3813− }
3814− }
3815−
3816− return syntheticFrame;
3817−}
3818−
3819−function describeClassComponentFrame(ctor, source, ownerFn) {
3820− {
3821− return describeNativeComponentFrame(ctor, true);
3822− }
3823−}
3824−function describeFunctionComponentFrame(fn, source, ownerFn) {
3825− {
3826− return describeNativeComponentFrame(fn, false);
3827− }
3828−}
3829−
3830−function shouldConstruct(Component) {
3831− var prototype = Component.prototype;
3832− return !!(prototype && prototype.isReactComponent);
3833−}
3834−
3835−function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
3836−
3837− if (type == null) {
3838− return '';
3839− }
3840−
3841− if (typeof type === 'function') {
3842− {
3843− return describeNativeComponentFrame(type, shouldConstruct(type));
3844− }
3845− }
3846−
3847− if (typeof type === 'string') {
3848− return describeBuiltInComponentFrame(type);
3849− }
3850−
3851− switch (type) {
3852− case REACT_SUSPENSE_TYPE:
3853− return describeBuiltInComponentFrame('Suspense');
3854−
3855− case REACT_SUSPENSE_LIST_TYPE:
3856− return describeBuiltInComponentFrame('SuspenseList');
3857− }
3858−
3859− if (typeof type === 'object') {
3860− switch (type.$$typeof) {
3861− case REACT_FORWARD_REF_TYPE:
3862− return describeFunctionComponentFrame(type.render);
3863−
3864− case REACT_MEMO_TYPE:
3865− // Memo may contain any component type so we recursively resolve it.
3866− return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
3867−
3868− case REACT_LAZY_TYPE:
3869− {
3870− var lazyComponent = type;
3871− var payload = lazyComponent._payload;
3872− var init = lazyComponent._init;
3873−
3874− try {
3875− // Lazy may contain any component type so we recursively resolve it.
3876− return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
3877− } catch (x) {}
3878− }
3879− }
3880− }
3881−
3882− return '';
3883−}
3884−
3885−var loggedTypeFailures = {};
3886−var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
3887−
3888−function setCurrentlyValidatingElement(element) {
3889− {
3890− if (element) {
3891− var owner = element._owner;
3892− var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
3893− ReactDebugCurrentFrame.setExtraStackFrame(stack);
3894− } else {
3895− ReactDebugCurrentFrame.setExtraStackFrame(null);
3896− }
3897− }
3898−}
3899−
3900−function checkPropTypes(typeSpecs, values, location, componentName, element) {
3901− {
3902− // $FlowFixMe This is okay but Flow doesn't know it.
3903− var has = Function.call.bind(hasOwnProperty);
3904−
3905− for (var typeSpecName in typeSpecs) {
3906− if (has(typeSpecs, typeSpecName)) {
3907− var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
3908− // fail the render phase where it didn't fail before. So we log it.
3909− // After these have been cleaned up, we'll let them throw.
3910−
3911− try {
3912− // This is intentionally an invariant that gets caught. It's the same
3913− // behavior as without this statement except with a better message.
3914− if (typeof typeSpecs[typeSpecName] !== 'function') {
3915− // eslint-disable-next-line react-internal/prod-error-codes
3916− var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
3917− err.name = 'Invariant Violation';
3918− throw err;
3919− }
3920−
3921− error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
3922− } catch (ex) {
3923− error$1 = ex;
3924− }
3925−
3926− if (error$1 && !(error$1 instanceof Error)) {
3927− setCurrentlyValidatingElement(element);
3928−
3929− error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
3930−
3931− setCurrentlyValidatingElement(null);
3932− }
3933−
3934− if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
3935− // Only monitor this failure once because there tends to be a lot of the
3936− // same error.
3937− loggedTypeFailures[error$1.message] = true;
3938− setCurrentlyValidatingElement(element);
3939−
3940− error('Failed %s type: %s', location, error$1.message);
3941−
3942− setCurrentlyValidatingElement(null);
3943− }
3944− }
3945− }
3946− }
3947−}
3948−
3949−var warnedAboutMissingGetChildContext;
3950−
3951−{
3952− warnedAboutMissingGetChildContext = {};
3953−}
3954−
3955−var emptyContextObject = {};
3956−
3957−{
3958− Object.freeze(emptyContextObject);
3959−}
3960−
3961−function getMaskedContext(type, unmaskedContext) {
3962− {
3963− var contextTypes = type.contextTypes;
3964−
3965− if (!contextTypes) {
3966− return emptyContextObject;
3967− }
3968−
3969− var context = {};
3970−
3971− for (var key in contextTypes) {
3972− context[key] = unmaskedContext[key];
3973− }
3974−
3975− {
3976− var name = getComponentNameFromType(type) || 'Unknown';
3977− checkPropTypes(contextTypes, context, 'context', name);
3978− }
3979−
3980− return context;
3981− }
3982−}
3983−function processChildContext(instance, type, parentContext, childContextTypes) {
3984− {
3985− // TODO (bvaughn) Replace this behavior with an invariant() in the future.
3986− // It has only been added in Fiber to match the (unintentional) behavior in Stack.
3987− if (typeof instance.getChildContext !== 'function') {
3988− {
3989− var componentName = getComponentNameFromType(type) || 'Unknown';
3990−
3991− if (!warnedAboutMissingGetChildContext[componentName]) {
3992− warnedAboutMissingGetChildContext[componentName] = true;
3993−
3994− error('%s.childContextTypes is specified but there is no getChildContext() method ' + 'on the instance. You can either define getChildContext() on %s or remove ' + 'childContextTypes from it.', componentName, componentName);
3995− }
3996− }
3997−
3998− return parentContext;
3999− }
4000−
4001− var childContext = instance.getChildContext();
4002−
4003− for (var contextKey in childContext) {
4004− if (!(contextKey in childContextTypes)) {
4005− throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
4006− }
4007− }
4008−
4009− {
4010− var name = getComponentNameFromType(type) || 'Unknown';
4011− checkPropTypes(childContextTypes, childContext, 'child context', name);
4012− }
4013−
4014− return assign({}, parentContext, childContext);
4015− }
4016−}
4017−
4018−var rendererSigil;
4019−
4020−{
4021− // Use this to detect multiple renderers using the same context
4022− rendererSigil = {};
4023−} // Used to store the parent path of all context overrides in a shared linked list.
4024−// Forming a reverse tree.
4025−
4026−
4027−var rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
4028−// This global (actually thread local) state represents what state all those "current",
4029−// fields are currently in.
4030−
4031−var currentActiveSnapshot = null;
4032−
4033−function popNode(prev) {
4034− {
4035− prev.context._currentValue2 = prev.parentValue;
4036− }
4037−}
4038−
4039−function pushNode(next) {
4040− {
4041− next.context._currentValue2 = next.value;
4042− }
4043−}
4044−
4045−function popToNearestCommonAncestor(prev, next) {
4046− if (prev === next) ; else {
4047− popNode(prev);
4048− var parentPrev = prev.parent;
4049− var parentNext = next.parent;
4050−
4051− if (parentPrev === null) {
4052− if (parentNext !== null) {
4053− throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
4054− }
4055− } else {
4056− if (parentNext === null) {
4057− throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
4058− }
4059−
4060− popToNearestCommonAncestor(parentPrev, parentNext);
4061− } // On the way back, we push the new ones that weren't common.
4062−
4063−
4064− pushNode(next);
4065− }
4066−}
4067−
4068−function popAllPrevious(prev) {
4069− popNode(prev);
4070− var parentPrev = prev.parent;
4071−
4072− if (parentPrev !== null) {
4073− popAllPrevious(parentPrev);
4074− }
4075−}
4076−
4077−function pushAllNext(next) {
4078− var parentNext = next.parent;
4079−
4080− if (parentNext !== null) {
4081− pushAllNext(parentNext);
4082− }
4083−
4084− pushNode(next);
4085−}
4086−
4087−function popPreviousToCommonLevel(prev, next) {
4088− popNode(prev);
4089− var parentPrev = prev.parent;
4090−
4091− if (parentPrev === null) {
4092− throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
4093− }
4094−
4095− if (parentPrev.depth === next.depth) {
4096− // We found the same level. Now we just need to find a shared ancestor.
4097− popToNearestCommonAncestor(parentPrev, next);
4098− } else {
4099− // We must still be deeper.
4100− popPreviousToCommonLevel(parentPrev, next);
4101− }
4102−}
4103−
4104−function popNextToCommonLevel(prev, next) {
4105− var parentNext = next.parent;
4106−
4107− if (parentNext === null) {
4108− throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
4109− }
4110−
4111− if (prev.depth === parentNext.depth) {
4112− // We found the same level. Now we just need to find a shared ancestor.
4113− popToNearestCommonAncestor(prev, parentNext);
4114− } else {
4115− // We must still be deeper.
4116− popNextToCommonLevel(prev, parentNext);
4117− }
4118−
4119− pushNode(next);
4120−} // Perform context switching to the new snapshot.
4121−// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
4122−// updating all the context's current values. That way reads, always just read the current value.
4123−// At the cost of updating contexts even if they're never read by this subtree.
4124−
4125−
4126−function switchContext(newSnapshot) {
4127− // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
4128− // We also need to update any new contexts that are now on the stack with the deepest value.
4129− // The easiest way to update new contexts is to just reapply them in reverse order from the
4130− // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
4131− // for that. Therefore this algorithm is recursive.
4132− // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
4133− // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
4134− // 3) Then we reapply new contexts on the way back up the stack.
4135− var prev = currentActiveSnapshot;
4136− var next = newSnapshot;
4137−
4138− if (prev !== next) {
4139− if (prev === null) {
4140− // $FlowFixMe: This has to be non-null since it's not equal to prev.
4141− pushAllNext(next);
4142− } else if (next === null) {
4143− popAllPrevious(prev);
4144− } else if (prev.depth === next.depth) {
4145− popToNearestCommonAncestor(prev, next);
4146− } else if (prev.depth > next.depth) {
4147− popPreviousToCommonLevel(prev, next);
4148− } else {
4149− popNextToCommonLevel(prev, next);
4150− }
4151−
4152− currentActiveSnapshot = next;
4153− }
4154−}
4155−function pushProvider(context, nextValue) {
4156− var prevValue;
4157−
4158− {
4159− prevValue = context._currentValue2;
4160− context._currentValue2 = nextValue;
4161−
4162− {
4163− if (context._currentRenderer2 !== undefined && context._currentRenderer2 !== null && context._currentRenderer2 !== rendererSigil) {
4164− error('Detected multiple renderers concurrently rendering the ' + 'same context provider. This is currently unsupported.');
4165− }
4166−
4167− context._currentRenderer2 = rendererSigil;
4168− }
4169− }
4170−
4171− var prevNode = currentActiveSnapshot;
4172− var newNode = {
4173− parent: prevNode,
4174− depth: prevNode === null ? 0 : prevNode.depth + 1,
4175− context: context,
4176− parentValue: prevValue,
4177− value: nextValue
4178− };
4179− currentActiveSnapshot = newNode;
4180− return newNode;
4181−}
4182−function popProvider(context) {
4183− var prevSnapshot = currentActiveSnapshot;
4184−
4185− if (prevSnapshot === null) {
4186− throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
4187− }
4188−
4189− {
4190− if (prevSnapshot.context !== context) {
4191− error('The parent context is not the expected context. This is probably a bug in React.');
4192− }
4193− }
4194−
4195− {
4196− var _value = prevSnapshot.parentValue;
4197−
4198− if (_value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
4199− prevSnapshot.context._currentValue2 = prevSnapshot.context._defaultValue;
4200− } else {
4201− prevSnapshot.context._currentValue2 = _value;
4202− }
4203−
4204− {
4205− if (context._currentRenderer2 !== undefined && context._currentRenderer2 !== null && context._currentRenderer2 !== rendererSigil) {
4206− error('Detected multiple renderers concurrently rendering the ' + 'same context provider. This is currently unsupported.');
4207− }
4208−
4209− context._currentRenderer2 = rendererSigil;
4210− }
4211− }
4212−
4213− return currentActiveSnapshot = prevSnapshot.parent;
4214−}
4215−function getActiveContext() {
4216− return currentActiveSnapshot;
4217−}
4218−function readContext(context) {
4219− var value = context._currentValue2;
4220− return value;
4221−}
4222−
4223−/**
4224− * `ReactInstanceMap` maintains a mapping from a public facing stateful
4225− * instance (key) and the internal representation (value). This allows public
4226− * methods to accept the user facing instance as an argument and map them back
4227− * to internal methods.
4228− *
4229− * Note that this module is currently shared and assumed to be stateless.
4230− * If this becomes an actual Map, that will break.
4231− */
4232−function get(key) {
4233− return key._reactInternals;
4234−}
4235−function set(key, value) {
4236− key._reactInternals = value;
4237−}
4238−
4239−var didWarnAboutNoopUpdateForComponent = {};
4240−var didWarnAboutDeprecatedWillMount = {};
4241−var didWarnAboutUninitializedState;
4242−var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
4243−var didWarnAboutLegacyLifecyclesAndDerivedState;
4244−var didWarnAboutUndefinedDerivedState;
4245−var warnOnUndefinedDerivedState;
4246−var warnOnInvalidCallback;
4247−var didWarnAboutDirectlyAssigningPropsToState;
4248−var didWarnAboutContextTypeAndContextTypes;
4249−var didWarnAboutInvalidateContextType;
4250−
4251−{
4252− didWarnAboutUninitializedState = new Set();
4253− didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
4254− didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
4255− didWarnAboutDirectlyAssigningPropsToState = new Set();
4256− didWarnAboutUndefinedDerivedState = new Set();
4257− didWarnAboutContextTypeAndContextTypes = new Set();
4258− didWarnAboutInvalidateContextType = new Set();
4259− var didWarnOnInvalidCallback = new Set();
4260−
4261− warnOnInvalidCallback = function (callback, callerName) {
4262− if (callback === null || typeof callback === 'function') {
4263− return;
4264− }
4265−
4266− var key = callerName + '_' + callback;
4267−
4268− if (!didWarnOnInvalidCallback.has(key)) {
4269− didWarnOnInvalidCallback.add(key);
4270−
4271− error('%s(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callerName, callback);
4272− }
4273− };
4274−
4275− warnOnUndefinedDerivedState = function (type, partialState) {
4276− if (partialState === undefined) {
4277− var componentName = getComponentNameFromType(type) || 'Component';
4278−
4279− if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
4280− didWarnAboutUndefinedDerivedState.add(componentName);
4281−
4282− error('%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. ' + 'You have returned undefined.', componentName);
4283− }
4284− }
4285− };
4286−}
4287−
4288−function warnNoop(publicInstance, callerName) {
4289− {
4290− var _constructor = publicInstance.constructor;
4291− var componentName = _constructor && getComponentNameFromType(_constructor) || 'ReactClass';
4292− var warningKey = componentName + '.' + callerName;
4293−
4294− if (didWarnAboutNoopUpdateForComponent[warningKey]) {
4295− return;
4296− }
4297−
4298− error('%s(...): Can only update a mounting component. ' + 'This usually means you called %s() outside componentWillMount() on the server. ' + 'This is a no-op.\n\nPlease check the code for the %s component.', callerName, callerName, componentName);
4299−
4300− didWarnAboutNoopUpdateForComponent[warningKey] = true;
4301− }
4302−}
4303−
4304−var classComponentUpdater = {
4305− isMounted: function (inst) {
4306− return false;
4307− },
4308− enqueueSetState: function (inst, payload, callback) {
4309− var internals = get(inst);
4310−
4311− if (internals.queue === null) {
4312− warnNoop(inst, 'setState');
4313− } else {
4314− internals.queue.push(payload);
4315−
4316− {
4317− if (callback !== undefined && callback !== null) {
4318− warnOnInvalidCallback(callback, 'setState');
4319− }
4320− }
4321− }
4322− },
4323− enqueueReplaceState: function (inst, payload, callback) {
4324− var internals = get(inst);
4325− internals.replace = true;
4326− internals.queue = [payload];
4327−
4328− {
4329− if (callback !== undefined && callback !== null) {
4330− warnOnInvalidCallback(callback, 'setState');
4331− }
4332− }
4333− },
4334− enqueueForceUpdate: function (inst, callback) {
4335− var internals = get(inst);
4336−
4337− if (internals.queue === null) {
4338− warnNoop(inst, 'forceUpdate');
4339− } else {
4340− {
4341− if (callback !== undefined && callback !== null) {
4342− warnOnInvalidCallback(callback, 'setState');
4343− }
4344− }
4345− }
4346− }
4347−};
4348−
4349−function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
4350− var partialState = getDerivedStateFromProps(nextProps, prevState);
4351−
4352− {
4353− warnOnUndefinedDerivedState(ctor, partialState);
4354− } // Merge the partial state and the previous state.
4355−
4356−
4357− var newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
4358− return newState;
4359−}
4360−
4361−function constructClassInstance(ctor, props, maskedLegacyContext) {
4362− var context = emptyContextObject;
4363− var contextType = ctor.contextType;
4364−
4365− {
4366− if ('contextType' in ctor) {
4367− var isValid = // Allow null for conditional declaration
4368− contextType === null || contextType !== undefined && contextType.$$typeof === REACT_CONTEXT_TYPE && contextType._context === undefined; // Not a <Context.Consumer>
4369−
4370− if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
4371− didWarnAboutInvalidateContextType.add(ctor);
4372− var addendum = '';
4373−
4374− if (contextType === undefined) {
4375− addendum = ' However, it is set to undefined. ' + 'This can be caused by a typo or by mixing up named and default imports. ' + 'This can also happen due to a circular dependency, so ' + 'try moving the createContext() call to a separate file.';
4376− } else if (typeof contextType !== 'object') {
4377− addendum = ' However, it is set to a ' + typeof contextType + '.';
4378− } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
4379− addendum = ' Did you accidentally pass the Context.Provider instead?';
4380− } else if (contextType._context !== undefined) {
4381− // <Context.Consumer>
4382− addendum = ' Did you accidentally pass the Context.Consumer instead?';
4383− } else {
4384− addendum = ' However, it is set to an object with keys {' + Object.keys(contextType).join(', ') + '}.';
4385− }
4386−
4387− error('%s defines an invalid contextType. ' + 'contextType should point to the Context object returned by React.createContext().%s', getComponentNameFromType(ctor) || 'Component', addendum);
4388− }
4389− }
4390− }
4391−
4392− if (typeof contextType === 'object' && contextType !== null) {
4393− context = readContext(contextType);
4394− } else {
4395− context = maskedLegacyContext;
4396− }
4397−
4398− var instance = new ctor(props, context);
4399−
4400− {
4401− if (typeof ctor.getDerivedStateFromProps === 'function' && (instance.state === null || instance.state === undefined)) {
4402− var componentName = getComponentNameFromType(ctor) || 'Component';
4403−
4404− if (!didWarnAboutUninitializedState.has(componentName)) {
4405− didWarnAboutUninitializedState.add(componentName);
4406−
4407− error('`%s` uses `getDerivedStateFromProps` but its initial state is ' + '%s. This is not recommended. Instead, define the initial state by ' + 'assigning an object to `this.state` in the constructor of `%s`. ' + 'This ensures that `getDerivedStateFromProps` arguments have a consistent shape.', componentName, instance.state === null ? 'null' : 'undefined', componentName);
4408− }
4409− } // If new component APIs are defined, "unsafe" lifecycles won't be called.
4410− // Warn about these lifecycles if they are present.
4411− // Don't warn about react-lifecycles-compat polyfilled methods though.
4412−
4413−
4414− if (typeof ctor.getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function') {
4415− var foundWillMountName = null;
4416− var foundWillReceivePropsName = null;
4417− var foundWillUpdateName = null;
4418−
4419− if (typeof instance.componentWillMount === 'function' && instance.componentWillMount.__suppressDeprecationWarning !== true) {
4420− foundWillMountName = 'componentWillMount';
4421− } else if (typeof instance.UNSAFE_componentWillMount === 'function') {
4422− foundWillMountName = 'UNSAFE_componentWillMount';
4423− }
4424−
4425− if (typeof instance.componentWillReceiveProps === 'function' && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
4426− foundWillReceivePropsName = 'componentWillReceiveProps';
4427− } else if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
4428− foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';
4429− }
4430−
4431− if (typeof instance.componentWillUpdate === 'function' && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
4432− foundWillUpdateName = 'componentWillUpdate';
4433− } else if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
4434− foundWillUpdateName = 'UNSAFE_componentWillUpdate';
4435− }
4436−
4437− if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
4438− var _componentName = getComponentNameFromType(ctor) || 'Component';
4439−
4440− var newApiName = typeof ctor.getDerivedStateFromProps === 'function' ? 'getDerivedStateFromProps()' : 'getSnapshotBeforeUpdate()';
4441−
4442− if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
4443− didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
4444−
4445− error('Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' + '%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n' + 'The above lifecycles should be removed. Learn more about this warning here:\n' + 'https://reactjs.org/link/unsafe-component-lifecycles', _componentName, newApiName, foundWillMountName !== null ? "\n " + foundWillMountName : '', foundWillReceivePropsName !== null ? "\n " + foundWillReceivePropsName : '', foundWillUpdateName !== null ? "\n " + foundWillUpdateName : '');
4446− }
4447− }
4448− }
4449− }
4450−
4451− return instance;
4452−}
4453−
4454−function checkClassInstance(instance, ctor, newProps) {
4455− {
4456− var name = getComponentNameFromType(ctor) || 'Component';
4457− var renderPresent = instance.render;
4458−
4459− if (!renderPresent) {
4460− if (ctor.prototype && typeof ctor.prototype.render === 'function') {
4461− error('%s(...): No `render` method found on the returned component ' + 'instance: did you accidentally return an object from the constructor?', name);
4462− } else {
4463− error('%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', name);
4464− }
4465− }
4466−
4467− if (instance.getInitialState && !instance.getInitialState.isReactClassApproved && !instance.state) {
4468− error('getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', name);
4469− }
4470−
4471− if (instance.getDefaultProps && !instance.getDefaultProps.isReactClassApproved) {
4472− error('getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', name);
4473− }
4474−
4475− if (instance.propTypes) {
4476− error('propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', name);
4477− }
4478−
4479− if (instance.contextType) {
4480− error('contextType was defined as an instance property on %s. Use a static ' + 'property to define contextType instead.', name);
4481− }
4482−
4483− {
4484− if (instance.contextTypes) {
4485− error('contextTypes was defined as an instance property on %s. Use a static ' + 'property to define contextTypes instead.', name);
4486− }
4487−
4488− if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
4489− didWarnAboutContextTypeAndContextTypes.add(ctor);
4490−
4491− error('%s declares both contextTypes and contextType static properties. ' + 'The legacy contextTypes property will be ignored.', name);
4492− }
4493− }
4494−
4495− if (typeof instance.componentShouldUpdate === 'function') {
4496− error('%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', name);
4497− }
4498−
4499− if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== 'undefined') {
4500− error('%s has a method called shouldComponentUpdate(). ' + 'shouldComponentUpdate should not be used when extending React.PureComponent. ' + 'Please extend React.Component if shouldComponentUpdate is used.', getComponentNameFromType(ctor) || 'A pure component');
4501− }
4502−
4503− if (typeof instance.componentDidUnmount === 'function') {
4504− error('%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', name);
4505− }
4506−
4507− if (typeof instance.componentDidReceiveProps === 'function') {
4508− error('%s has a method called ' + 'componentDidReceiveProps(). But there is no such lifecycle method. ' + 'If you meant to update the state in response to changing props, ' + 'use componentWillReceiveProps(). If you meant to fetch data or ' + 'run side-effects or mutations after React has updated the UI, use componentDidUpdate().', name);
4509− }
4510−
4511− if (typeof instance.componentWillRecieveProps === 'function') {
4512− error('%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', name);
4513− }
4514−
4515− if (typeof instance.UNSAFE_componentWillRecieveProps === 'function') {
4516− error('%s has a method called ' + 'UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?', name);
4517− }
4518−
4519− var hasMutatedProps = instance.props !== newProps;
4520−
4521− if (instance.props !== undefined && hasMutatedProps) {
4522− error('%s(...): When calling super() in `%s`, make sure to pass ' + "up the same props that your component's constructor was passed.", name, name);
4523− }
4524−
4525− if (instance.defaultProps) {
4526− error('Setting defaultProps as an instance property on %s is not supported and will be ignored.' + ' Instead, define defaultProps as a static property on %s.', name, name);
4527− }
4528−
4529− if (typeof instance.getSnapshotBeforeUpdate === 'function' && typeof instance.componentDidUpdate !== 'function' && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
4530− didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
4531−
4532− error('%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). ' + 'This component defines getSnapshotBeforeUpdate() only.', getComponentNameFromType(ctor));
4533− }
4534−
4535− if (typeof instance.getDerivedStateFromProps === 'function') {
4536− error('%s: getDerivedStateFromProps() is defined as an instance method ' + 'and will be ignored. Instead, declare it as a static method.', name);
4537− }
4538−
4539− if (typeof instance.getDerivedStateFromError === 'function') {
4540− error('%s: getDerivedStateFromError() is defined as an instance method ' + 'and will be ignored. Instead, declare it as a static method.', name);
4541− }
4542−
4543− if (typeof ctor.getSnapshotBeforeUpdate === 'function') {
4544− error('%s: getSnapshotBeforeUpdate() is defined as a static method ' + 'and will be ignored. Instead, declare it as an instance method.', name);
4545− }
4546−
4547− var _state = instance.state;
4548−
4549− if (_state && (typeof _state !== 'object' || isArray(_state))) {
4550− error('%s.state: must be set to an object or null', name);
4551− }
4552−
4553− if (typeof instance.getChildContext === 'function' && typeof ctor.childContextTypes !== 'object') {
4554− error('%s.getChildContext(): childContextTypes must be defined in order to ' + 'use getChildContext().', name);
4555− }
4556− }
4557−}
4558−
4559−function callComponentWillMount(type, instance) {
4560− var oldState = instance.state;
4561−
4562− if (typeof instance.componentWillMount === 'function') {
4563− {
4564− if ( instance.componentWillMount.__suppressDeprecationWarning !== true) {
4565− var componentName = getComponentNameFromType(type) || 'Unknown';
4566−
4567− if (!didWarnAboutDeprecatedWillMount[componentName]) {
4568− warn( // keep this warning in sync with ReactStrictModeWarning.js
4569− 'componentWillMount has been renamed, and is not recommended for use. ' + 'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n' + '* Move code from componentWillMount to componentDidMount (preferred in most cases) ' + 'or the constructor.\n' + '\nPlease update the following components: %s', componentName);
4570−
4571− didWarnAboutDeprecatedWillMount[componentName] = true;
4572− }
4573− }
4574− }
4575−
4576− instance.componentWillMount();
4577− }
4578−
4579− if (typeof instance.UNSAFE_componentWillMount === 'function') {
4580− instance.UNSAFE_componentWillMount();
4581− }
4582−
4583− if (oldState !== instance.state) {
4584− {
4585− error('%s.componentWillMount(): Assigning directly to this.state is ' + "deprecated (except inside a component's " + 'constructor). Use setState instead.', getComponentNameFromType(type) || 'Component');
4586− }
4587−
4588− classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
4589− }
4590−}
4591−
4592−function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
4593− if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
4594− var oldQueue = internalInstance.queue;
4595− var oldReplace = internalInstance.replace;
4596− internalInstance.queue = null;
4597− internalInstance.replace = false;
4598−
4599− if (oldReplace && oldQueue.length === 1) {
4600− inst.state = oldQueue[0];
4601− } else {
4602− var nextState = oldReplace ? oldQueue[0] : inst.state;
4603− var dontMutate = true;
4604−
4605− for (var i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
4606− var partial = oldQueue[i];
4607− var partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
4608−
4609− if (partialState != null) {
4610− if (dontMutate) {
4611− dontMutate = false;
4612− nextState = assign({}, nextState, partialState);
4613− } else {
4614− assign(nextState, partialState);
2118+ null != formAction$jscomp$1 &&
2119+ pushAttribute(target$jscomp$0, "action", formAction$jscomp$1);
2120+ null != formEncType$jscomp$1 &&
2121+ pushAttribute(target$jscomp$0, "encType", formEncType$jscomp$1);
2122+ null != formMethod$jscomp$1 &&
2123+ pushAttribute(target$jscomp$0, "method", formMethod$jscomp$1);
2124+ null != formTarget$jscomp$1 &&
2125+ pushAttribute(target$jscomp$0, "target", formTarget$jscomp$1);
2126+ target$jscomp$0.push(endOfStartTag);
2127+ null !== formActionName &&
2128+ (target$jscomp$0.push('<input type="hidden"'),
2129+ pushStringAttribute(target$jscomp$0, "name", formActionName),
2130+ target$jscomp$0.push(endOfStartTagSelfClosing),
2131+ null != formData$jscomp$1 &&
2132+ formData$jscomp$1.forEach(
2133+ pushAdditionalFormField,
2134+ target$jscomp$0
2135+ ));
2136+ pushInnerHTML(target$jscomp$0, innerHTML$jscomp$3, children$jscomp$4);
2137+ if ("string" === typeof children$jscomp$4) {
2138+ target$jscomp$0.push(escapeTextForBrowser(children$jscomp$4));
2139+ var JSCompiler_inline_result$jscomp$2 = null;
2140+ } else JSCompiler_inline_result$jscomp$2 = children$jscomp$4;
2141+ return JSCompiler_inline_result$jscomp$2;
2142+ case "menuitem":
2143+ target$jscomp$0.push(startChunkForTag("menuitem"));
2144+ for (var propKey$jscomp$6 in props)
2145+ if (hasOwnProperty.call(props, propKey$jscomp$6)) {
2146+ var propValue$jscomp$6 = props[propKey$jscomp$6];
2147+ if (null != propValue$jscomp$6)
2148+ switch (propKey$jscomp$6) {
2149+ case "children":
2150+ case "dangerouslySetInnerHTML":
2151+ throw Error(
2152+ "menuitems cannot have `children` nor `dangerouslySetInnerHTML`."
2153+ );
2154+ default:
2155+ pushAttribute(
2156+ target$jscomp$0,
2157+ propKey$jscomp$6,
2158+ propValue$jscomp$6
2159+ );
2160+ }
2161+ }
2162+ target$jscomp$0.push(endOfStartTag);
2163+ return null;
2164+ case "object":
2165+ target$jscomp$0.push(startChunkForTag("object"));
2166+ var children$jscomp$5 = null,
2167+ innerHTML$jscomp$4 = null,
2168+ propKey$jscomp$7;
2169+ for (propKey$jscomp$7 in props)
2170+ if (hasOwnProperty.call(props, propKey$jscomp$7)) {
2171+ var propValue$jscomp$7 = props[propKey$jscomp$7];
2172+ if (null != propValue$jscomp$7)
2173+ switch (propKey$jscomp$7) {
2174+ case "children":
2175+ children$jscomp$5 = propValue$jscomp$7;
2176+ break;
2177+ case "dangerouslySetInnerHTML":
2178+ innerHTML$jscomp$4 = propValue$jscomp$7;
2179+ break;
2180+ case "data":
2181+ checkAttributeStringCoercion(propValue$jscomp$7, "data");
2182+ var sanitizedValue = sanitizeURL("" + propValue$jscomp$7);
2183+ if ("" === sanitizedValue) {
2184+ console.error(
2185+ 'An empty string ("") was passed to the %s attribute. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
2186+ propKey$jscomp$7,
2187+ propKey$jscomp$7
2188+ );
2189+ break;
2190+ }
2191+ target$jscomp$0.push(
2192+ attributeSeparator,
2193+ "data",
2194+ attributeAssign,
2195+ escapeTextForBrowser(sanitizedValue),
2196+ attributeEnd
2197+ );
2198+ break;
2199+ default:
2200+ pushAttribute(
2201+ target$jscomp$0,
2202+ propKey$jscomp$7,
2203+ propValue$jscomp$7
2204+ );
2205+ }
2206+ }
2207+ target$jscomp$0.push(endOfStartTag);
2208+ pushInnerHTML(target$jscomp$0, innerHTML$jscomp$4, children$jscomp$5);
2209+ if ("string" === typeof children$jscomp$5) {
2210+ target$jscomp$0.push(escapeTextForBrowser(children$jscomp$5));
2211+ var JSCompiler_inline_result$jscomp$3 = null;
2212+ } else JSCompiler_inline_result$jscomp$3 = children$jscomp$5;
2213+ return JSCompiler_inline_result$jscomp$3;
2214+ case "title":
2215+ var noscriptTagInScope = formatContext.tagScope & 1,
2216+ isFallback = formatContext.tagScope & 4;
2217+ if (hasOwnProperty.call(props, "children")) {
2218+ var children$jscomp$6 = props.children,
2219+ child = Array.isArray(children$jscomp$6)
2220+ ? 2 > children$jscomp$6.length
2221+ ? children$jscomp$6[0]
2222+ : null
2223+ : children$jscomp$6;
2224+ Array.isArray(children$jscomp$6) && 1 < children$jscomp$6.length
2225+ ? console.error(
2226+ "React expects the `children` prop of <title> tags to be a string, number, bigint, or object with a novel `toString` method but found an Array with length %s instead. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert `children` of <title> tags to a single string value which is why Arrays of length greater than 1 are not supported. When using JSX it can be common to combine text nodes and value nodes. For example: <title>hello {nameOfUser}</title>. While not immediately apparent, `children` in this case is an Array with length 2. If your `children` prop is using this form try rewriting it using a template string: <title>{`hello ${nameOfUser}`}</title>.",
2227+ children$jscomp$6.length
2228+ )
2229+ : "function" === typeof child || "symbol" === typeof child
2230+ ? console.error(
2231+ "React expect children of <title> tags to be a string, number, bigint, or object with a novel `toString` method but found %s instead. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value.",
2232+ "function" === typeof child ? "a Function" : "a Sybmol"
2233+ )
2234+ : child &&
2235+ child.toString === {}.toString &&
2236+ (null != child.$$typeof
2237+ ? console.error(
2238+ "React expects the `children` prop of <title> tags to be a string, number, bigint, or object with a novel `toString` method but found an object that appears to be a React element which never implements a suitable `toString` method. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value which is why rendering React elements is not supported. If the `children` of <title> is a React Component try moving the <title> tag into that component. If the `children` of <title> is some HTML markup change it to be Text only to be valid HTML."
2239+ )
2240+ : console.error(
2241+ "React expects the `children` prop of <title> tags to be a string, number, bigint, or object with a novel `toString` method but found an object that does not implement a suitable `toString` method. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value. Using the default `toString` method available on every object is almost certainly an error. Consider whether the `children` of this <title> is an object in error and change it to a string or number value if so. Otherwise implement a `toString` method that React can use to produce a valid <title>."
2242+ ));
46152243 }
4616− }
4617− }
4618−
4619− inst.state = nextState;
4620− }
4621− } else {
4622− internalInstance.queue = null;
4623− }
4624−} // Invokes the mount life-cycles on a previously never rendered instance.
4625−
4626−
4627−function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
4628− {
4629− checkClassInstance(instance, ctor, newProps);
4630− }
4631−
4632− var initialState = instance.state !== undefined ? instance.state : null;
4633− instance.updater = classComponentUpdater;
4634− instance.props = newProps;
4635− instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
4636− // The internal instance will be used to manage updates that happen during this mount.
4637−
4638− var internalInstance = {
4639− queue: [],
4640− replace: false
4641− };
4642− set(instance, internalInstance);
4643− var contextType = ctor.contextType;
4644−
4645− if (typeof contextType === 'object' && contextType !== null) {
4646− instance.context = readContext(contextType);
4647− } else {
4648− instance.context = maskedLegacyContext;
4649− }
4650−
4651− {
4652− if (instance.state === newProps) {
4653− var componentName = getComponentNameFromType(ctor) || 'Component';
4654−
4655− if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
4656− didWarnAboutDirectlyAssigningPropsToState.add(componentName);
4657−
4658− error('%s: It is not recommended to assign props directly to state ' + "because updates to props won't be reflected in state. " + 'In most cases, it is better to use props directly.', componentName);
4659− }
4660− }
4661− }
4662−
4663− var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
4664−
4665− if (typeof getDerivedStateFromProps === 'function') {
4666− instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
4667− } // In order to support react-lifecycles-compat polyfilled components,
4668− // Unsafe lifecycles should not be invoked for components using the new APIs.
4669−
4670−
4671− if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
4672− callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
4673− // process them now.
4674−
4675− processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
4676− }
4677−}
4678−
4679−// Ids are base 32 strings whose binary representation corresponds to the
4680−// position of a node in a tree.
4681−// Every time the tree forks into multiple children, we add additional bits to
4682−// the left of the sequence that represent the position of the child within the
4683−// current level of children.
4684−//
4685−// 00101 00010001011010101
4686−// ╰─┬─╯ ╰───────┬───────╯
4687−// Fork 5 of 20 Parent id
4688−//
4689−// The leading 0s are important. In the above example, you only need 3 bits to
4690−// represent slot 5. However, you need 5 bits to represent all the forks at
4691−// the current level, so we must account for the empty bits at the end.
4692−//
4693−// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
4694−// the zeroth id at a level would be indistinguishable from its parent.
4695−//
4696−// If a node has only one child, and does not materialize an id (i.e. does not
4697−// contain a useId hook), then we don't need to allocate any space in the
4698−// sequence. It's treated as a transparent indirection. For example, these two
4699−// trees produce the same ids:
4700−//
4701−// <> <>
4702−// <Indirection> <A />
4703−// <A /> <B />
4704−// </Indirection> </>
4705−// <B />
4706−// </>
4707−//
4708−// However, we cannot skip any node that materializes an id. Otherwise, a parent
4709−// id that does not fork would be indistinguishable from its child id. For
4710−// example, this tree does not fork, but the parent and child must have
4711−// different ids.
4712−//
4713−// <Parent>
4714−// <Child />
4715−// </Parent>
4716−//
4717−// To handle this scenario, every time we materialize an id, we allocate a
4718−// new level with a single slot. You can think of this as a fork with only one
4719−// prong, or an array of children with length 1.
4720−//
4721−// It's possible for the size of the sequence to exceed 32 bits, the max
4722−// size for bitwise operations. When this happens, we make more room by
4723−// converting the right part of the id to a string and storing it in an overflow
4724−// variable. We use a base 32 string representation, because 32 is the largest
4725−// power of 2 that is supported by toString(). We want the base to be large so
4726−// that the resulting ids are compact, and we want the base to be a power of 2
4727−// because every log2(base) bits corresponds to a single character, i.e. every
4728−// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
4729−// affecting the final result.
4730−var emptyTreeContext = {
4731− id: 1,
4732− overflow: ''
4733−};
4734−function getTreeId(context) {
4735− var overflow = context.overflow;
4736− var idWithLeadingBit = context.id;
4737− var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
4738− return id.toString(32) + overflow;
4739−}
4740−function pushTreeContext(baseContext, totalChildren, index) {
4741− var baseIdWithLeadingBit = baseContext.id;
4742− var baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
4743− // of the id; we use it to account for leading 0s.
4744−
4745− var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
4746− var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
4747− var slot = index + 1;
4748− var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
4749− // consideration the leading 1 we use to mark the end of the sequence.
4750−
4751− if (length > 30) {
4752− // We overflowed the bitwise-safe range. Fall back to slower algorithm.
4753− // This branch assumes the length of the base id is greater than 5; it won't
4754− // work for smaller ids, because you need 5 bits per character.
4755− //
4756− // We encode the id in multiple steps: first the base id, then the
4757− // remaining digits.
4758− //
4759− // Each 5 bit sequence corresponds to a single base 32 character. So for
4760− // example, if the current id is 23 bits long, we can convert 20 of those
4761− // bits into a string of 4 characters, with 3 bits left over.
4762− //
4763− // First calculate how many bits in the base id represent a complete
4764− // sequence of characters.
4765− var numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
4766−
4767− var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
4768−
4769− var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
4770−
4771− var restOfBaseId = baseId >> numberOfOverflowBits;
4772− var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
4773− // we made more room, this time it won't overflow.
4774−
4775− var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
4776− var restOfNewBits = slot << restOfBaseLength;
4777− var id = restOfNewBits | restOfBaseId;
4778− var overflow = newOverflow + baseOverflow;
4779− return {
4780− id: 1 << restOfLength | id,
4781− overflow: overflow
4782− };
4783− } else {
4784− // Normal path
4785− var newBits = slot << baseLength;
4786−
4787− var _id = newBits | baseId;
4788−
4789− var _overflow = baseOverflow;
4790− return {
4791− id: 1 << length | _id,
4792− overflow: _overflow
4793− };
4794− }
4795−}
4796−
4797−function getBitLength(number) {
4798− return 32 - clz32(number);
4799−}
4800−
4801−function getLeadingBit(id) {
4802− return 1 << getBitLength(id) - 1;
4803−} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
4804−
4805−
4806−var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback; // Count leading zeros.
4807−// Based on:
4808−// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
4809−
4810−var log = Math.log;
4811−var LN2 = Math.LN2;
4812−
4813−function clz32Fallback(x) {
4814− var asUint = x >>> 0;
4815−
4816− if (asUint === 0) {
4817− return 32;
4818− }
4819−
4820− return 31 - (log(asUint) / LN2 | 0) | 0;
4821−}
4822−
4823−/**
4824− * inlined Object.is polyfill to avoid requiring consumers ship their own
4825− * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
4826− */
4827−function is(x, y) {
4828− return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
4829− ;
4830−}
4831−
4832−var objectIs = typeof Object.is === 'function' ? Object.is : is;
4833−
4834−var currentlyRenderingComponent = null;
4835−var currentlyRenderingTask = null;
4836−var firstWorkInProgressHook = null;
4837−var workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
4838−
4839−var isReRender = false; // Whether an update was scheduled during the currently executing render pass.
4840−
4841−var didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
4842−
4843−var localIdCounter = 0; // Lazily created map of render-phase updates
4844−
4845−var renderPhaseUpdates = null; // Counter to prevent infinite loops.
4846−
4847−var numberOfReRenders = 0;
4848−var RE_RENDER_LIMIT = 25;
4849−var isInHookUserCodeInDev = false; // In DEV, this is the name of the currently executing primitive hook
4850−
4851−var currentHookNameInDev;
4852−
4853−function resolveCurrentlyRenderingComponent() {
4854− if (currentlyRenderingComponent === null) {
4855− throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
4856− }
4857−
4858− {
4859− if (isInHookUserCodeInDev) {
4860− error('Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. ' + 'You can only call Hooks at the top level of your React function. ' + 'For more information, see ' + 'https://reactjs.org/link/rules-of-hooks');
4861− }
4862− }
4863−
4864− return currentlyRenderingComponent;
4865−}
4866−
4867−function areHookInputsEqual(nextDeps, prevDeps) {
4868− if (prevDeps === null) {
4869− {
4870− error('%s received a final argument during this render, but not during ' + 'the previous render. Even though the final argument is optional, ' + 'its type cannot change between renders.', currentHookNameInDev);
4871− }
4872−
4873− return false;
4874− }
4875−
4876− {
4877− // Don't bother comparing lengths in prod because these arrays should be
4878− // passed inline.
4879− if (nextDeps.length !== prevDeps.length) {
4880− error('The final argument passed to %s changed size between renders. The ' + 'order and size of this array must remain constant.\n\n' + 'Previous: %s\n' + 'Incoming: %s', currentHookNameInDev, "[" + nextDeps.join(', ') + "]", "[" + prevDeps.join(', ') + "]");
4881− }
4882− }
4883−
4884− for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
4885− if (objectIs(nextDeps[i], prevDeps[i])) {
4886− continue;
4887− }
4888−
4889− return false;
4890− }
4891−
4892− return true;
4893−}
4894−
4895−function createHook() {
4896− if (numberOfReRenders > 0) {
4897− throw new Error('Rendered more hooks than during the previous render');
4898− }
4899−
4900− return {
4901− memoizedState: null,
4902− queue: null,
4903− next: null
4904− };
4905−}
4906−
4907−function createWorkInProgressHook() {
4908− if (workInProgressHook === null) {
4909− // This is the first hook in the list
4910− if (firstWorkInProgressHook === null) {
4911− isReRender = false;
4912− firstWorkInProgressHook = workInProgressHook = createHook();
4913− } else {
4914− // There's already a work-in-progress. Reuse it.
4915− isReRender = true;
4916− workInProgressHook = firstWorkInProgressHook;
4917− }
4918− } else {
4919− if (workInProgressHook.next === null) {
4920− isReRender = false; // Append to the end of the list
4921−
4922− workInProgressHook = workInProgressHook.next = createHook();
4923− } else {
4924− // There's already a work-in-progress. Reuse it.
4925− isReRender = true;
4926− workInProgressHook = workInProgressHook.next;
4927− }
4928− }
4929−
4930− return workInProgressHook;
4931−}
4932−
4933−function prepareToUseHooks(task, componentIdentity) {
4934− currentlyRenderingComponent = componentIdentity;
4935− currentlyRenderingTask = task;
4936−
4937− {
4938− isInHookUserCodeInDev = false;
4939− } // The following should have already been reset
4940− // didScheduleRenderPhaseUpdate = false;
4941− // localIdCounter = 0;
4942− // firstWorkInProgressHook = null;
4943− // numberOfReRenders = 0;
4944− // renderPhaseUpdates = null;
4945− // workInProgressHook = null;
4946−
4947−
4948− localIdCounter = 0;
4949−}
4950−function finishHooks(Component, props, children, refOrContext) {
4951− // This must be called after every function component to prevent hooks from
4952− // being used in classes.
4953− while (didScheduleRenderPhaseUpdate) {
4954− // Updates were scheduled during the render phase. They are stored in
4955− // the `renderPhaseUpdates` map. Call the component again, reusing the
4956− // work-in-progress hooks and applying the additional updates on top. Keep
4957− // restarting until no more updates are scheduled.
4958− didScheduleRenderPhaseUpdate = false;
4959− localIdCounter = 0;
4960− numberOfReRenders += 1; // Start over from the beginning of the list
4961−
4962− workInProgressHook = null;
4963− children = Component(props, refOrContext);
4964− }
4965−
4966− resetHooksState();
4967− return children;
4968−}
4969−function checkDidRenderIdHook() {
4970− // This should be called immediately after every finishHooks call.
4971− // Conceptually, it's part of the return value of finishHooks; it's only a
4972− // separate function to avoid using an array tuple.
4973− var didRenderIdHook = localIdCounter !== 0;
4974− return didRenderIdHook;
4975−} // Reset the internal hooks state if an error occurs while rendering a component
4976−
4977−function resetHooksState() {
4978− {
4979− isInHookUserCodeInDev = false;
4980− }
4981−
4982− currentlyRenderingComponent = null;
4983− currentlyRenderingTask = null;
4984− didScheduleRenderPhaseUpdate = false;
4985− firstWorkInProgressHook = null;
4986− numberOfReRenders = 0;
4987− renderPhaseUpdates = null;
4988− workInProgressHook = null;
4989−}
4990−
4991−function readContext$1(context) {
4992− {
4993− if (isInHookUserCodeInDev) {
4994− error('Context can only be read while React is rendering. ' + 'In classes, you can read it in the render method or getDerivedStateFromProps. ' + 'In function components, you can read it directly in the function body, but not ' + 'inside Hooks like useReducer() or useMemo().');
4995− }
4996− }
4997−
4998− return readContext(context);
4999−}
5000−
5001−function useContext(context) {
5002− {
5003− currentHookNameInDev = 'useContext';
5004− }
5005−
5006− resolveCurrentlyRenderingComponent();
5007− return readContext(context);
5008−}
5009−
5010−function basicStateReducer(state, action) {
5011− // $FlowFixMe: Flow doesn't like mixed types
5012− return typeof action === 'function' ? action(state) : action;
5013−}
5014−
5015−function useState(initialState) {
5016− {
5017− currentHookNameInDev = 'useState';
5018− }
5019−
5020− return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
5021− initialState);
5022−}
5023−function useReducer(reducer, initialArg, init) {
5024− {
5025− if (reducer !== basicStateReducer) {
5026− currentHookNameInDev = 'useReducer';
5027− }
5028− }
5029−
5030− currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
5031− workInProgressHook = createWorkInProgressHook();
5032−
5033− if (isReRender) {
5034− // This is a re-render. Apply the new render phase updates to the previous
5035− // current hook.
5036− var queue = workInProgressHook.queue;
5037− var dispatch = queue.dispatch;
5038−
5039− if (renderPhaseUpdates !== null) {
5040− // Render phase updates are stored in a map of queue -> linked list
5041− var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
5042−
5043− if (firstRenderPhaseUpdate !== undefined) {
5044− renderPhaseUpdates.delete(queue);
5045− var newState = workInProgressHook.memoizedState;
5046− var update = firstRenderPhaseUpdate;
5047−
5048− do {
5049− // Process this render phase update. We don't have to check the
5050− // priority because it will always be the same as the current
5051− // render's.
5052− var action = update.action;
5053−
5054− {
5055− isInHookUserCodeInDev = true;
2244+ if (
2245+ formatContext.insertionMode === SVG_MODE ||
2246+ noscriptTagInScope ||
2247+ null != props.itemProp
2248+ )
2249+ var JSCompiler_inline_result$jscomp$4 = pushTitleImpl(
2250+ target$jscomp$0,
2251+ props
2252+ );
2253+ else
2254+ isFallback
2255+ ? (JSCompiler_inline_result$jscomp$4 = null)
2256+ : (pushTitleImpl(renderState.hoistableChunks, props),
2257+ (JSCompiler_inline_result$jscomp$4 = void 0));
2258+ return JSCompiler_inline_result$jscomp$4;
2259+ case "link":
2260+ var noscriptTagInScope$jscomp$0 = formatContext.tagScope & 1,
2261+ isFallback$jscomp$0 = formatContext.tagScope & 4,
2262+ rel = props.rel,
2263+ href = props.href,
2264+ precedence = props.precedence;
2265+ if (
2266+ formatContext.insertionMode === SVG_MODE ||
2267+ noscriptTagInScope$jscomp$0 ||
2268+ null != props.itemProp ||
2269+ "string" !== typeof rel ||
2270+ "string" !== typeof href ||
2271+ "" === href
2272+ ) {
2273+ "stylesheet" === rel &&
2274+ "string" === typeof props.precedence &&
2275+ (("string" === typeof href && href) ||
2276+ console.error(
2277+ 'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and expected the `href` prop to be a non-empty string but ecountered %s instead. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop ensure there is a non-empty string `href` prop as well, otherwise remove the `precedence` prop.',
2278+ null === href
2279+ ? "`null`"
2280+ : void 0 === href
2281+ ? "`undefined`"
2282+ : "" === href
2283+ ? "an empty string"
2284+ : 'something with type "' + typeof href + '"'
2285+ ));
2286+ pushLinkImpl(target$jscomp$0, props);
2287+ var JSCompiler_inline_result$jscomp$5 = null;
2288+ } else if ("stylesheet" === props.rel)
2289+ if (
2290+ "string" !== typeof precedence ||
2291+ null != props.disabled ||
2292+ props.onLoad ||
2293+ props.onError
2294+ ) {
2295+ if ("string" === typeof precedence)
2296+ if (null != props.disabled)
2297+ console.error(
2298+ 'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and a `disabled` prop. The presence of the `disabled` prop indicates an intent to manage the stylesheet active state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the `disabled` prop, otherwise remove the `precedence` prop.'
2299+ );
2300+ else if (props.onLoad || props.onError) {
2301+ var propDescription =
2302+ props.onLoad && props.onError
2303+ ? "`onLoad` and `onError` props"
2304+ : props.onLoad
2305+ ? "`onLoad` prop"
2306+ : "`onError` prop";
2307+ console.error(
2308+ 'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and %s. The presence of loading and error handlers indicates an intent to manage the stylesheet loading state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.',
2309+ propDescription,
2310+ propDescription
2311+ );
2312+ }
2313+ JSCompiler_inline_result$jscomp$5 = pushLinkImpl(
2314+ target$jscomp$0,
2315+ props
2316+ );
2317+ } else {
2318+ var styleQueue = renderState.styles.get(precedence),
2319+ resourceState = resumableState.styleResources.hasOwnProperty(
2320+ href
2321+ )
2322+ ? resumableState.styleResources[href]
2323+ : void 0;
2324+ if (resourceState !== EXISTS) {
2325+ resumableState.styleResources[href] = EXISTS;
2326+ styleQueue ||
2327+ ((styleQueue = {
2328+ precedence: escapeTextForBrowser(precedence),
2329+ rules: [],
2330+ hrefs: [],
2331+ sheets: new Map()
2332+ }),
2333+ renderState.styles.set(precedence, styleQueue));
2334+ var resource = {
2335+ state: PENDING$1,
2336+ props: assign({}, props, {
2337+ "data-precedence": props.precedence,
2338+ precedence: null
2339+ })
2340+ };
2341+ if (resourceState) {
2342+ 2 === resourceState.length &&
2343+ adoptPreloadCredentials(resource.props, resourceState);
2344+ var preloadResource =
2345+ renderState.preloads.stylesheets.get(href);
2346+ preloadResource && 0 < preloadResource.length
2347+ ? (preloadResource.length = 0)
2348+ : (resource.state = PRELOADED);
2349+ }
2350+ styleQueue.sheets.set(href, resource);
2351+ hoistableState && hoistableState.stylesheets.add(resource);
2352+ } else if (styleQueue) {
2353+ var _resource = styleQueue.sheets.get(href);
2354+ _resource &&
2355+ hoistableState &&
2356+ hoistableState.stylesheets.add(_resource);
2357+ }
2358+ textEmbedded && target$jscomp$0.push("\x3c!-- --\x3e");
2359+ JSCompiler_inline_result$jscomp$5 = null;
2360+ }
2361+ else
2362+ props.onLoad || props.onError
2363+ ? (JSCompiler_inline_result$jscomp$5 = pushLinkImpl(
2364+ target$jscomp$0,
2365+ props
2366+ ))
2367+ : (textEmbedded && target$jscomp$0.push("\x3c!-- --\x3e"),
2368+ (JSCompiler_inline_result$jscomp$5 = isFallback$jscomp$0
2369+ ? null
2370+ : pushLinkImpl(renderState.hoistableChunks, props)));
2371+ return JSCompiler_inline_result$jscomp$5;
2372+ case "script":
2373+ var noscriptTagInScope$jscomp$1 = formatContext.tagScope & 1,
2374+ asyncProp = props.async;
2375+ if (
2376+ "string" !== typeof props.src ||
2377+ !props.src ||
2378+ !asyncProp ||
2379+ "function" === typeof asyncProp ||
2380+ "symbol" === typeof asyncProp ||
2381+ props.onLoad ||
2382+ props.onError ||
2383+ formatContext.insertionMode === SVG_MODE ||
2384+ noscriptTagInScope$jscomp$1 ||
2385+ null != props.itemProp
2386+ )
2387+ var JSCompiler_inline_result$jscomp$6 = pushScriptImpl(
2388+ target$jscomp$0,
2389+ props
2390+ );
2391+ else {
2392+ var key = props.src;
2393+ if ("module" === props.type) {
2394+ var resources = resumableState.moduleScriptResources;
2395+ var preloads = renderState.preloads.moduleScripts;
2396+ } else
2397+ (resources = resumableState.scriptResources),
2398+ (preloads = renderState.preloads.scripts);
2399+ var resourceState$jscomp$0 = resources.hasOwnProperty(key)
2400+ ? resources[key]
2401+ : void 0;
2402+ if (resourceState$jscomp$0 !== EXISTS) {
2403+ resources[key] = EXISTS;
2404+ var scriptProps = props;
2405+ if (resourceState$jscomp$0) {
2406+ 2 === resourceState$jscomp$0.length &&
2407+ ((scriptProps = assign({}, props)),
2408+ adoptPreloadCredentials(scriptProps, resourceState$jscomp$0));
2409+ var preloadResource$jscomp$0 = preloads.get(key);
2410+ preloadResource$jscomp$0 &&
2411+ (preloadResource$jscomp$0.length = 0);
2412+ }
2413+ var resource$jscomp$0 = [];
2414+ renderState.scripts.add(resource$jscomp$0);
2415+ pushScriptImpl(resource$jscomp$0, scriptProps);
2416+ }
2417+ textEmbedded && target$jscomp$0.push("\x3c!-- --\x3e");
2418+ JSCompiler_inline_result$jscomp$6 = null;
50562419 }
5057−
5058− newState = reducer(newState, action);
5059−
5060− {
5061− isInHookUserCodeInDev = false;
2420+ return JSCompiler_inline_result$jscomp$6;
2421+ case "style":
2422+ var noscriptTagInScope$jscomp$2 = formatContext.tagScope & 1;
2423+ if (hasOwnProperty.call(props, "children")) {
2424+ var children$jscomp$7 = props.children,
2425+ child$jscomp$0 = Array.isArray(children$jscomp$7)
2426+ ? 2 > children$jscomp$7.length
2427+ ? children$jscomp$7[0]
2428+ : null
2429+ : children$jscomp$7;
2430+ ("function" === typeof child$jscomp$0 ||
2431+ "symbol" === typeof child$jscomp$0 ||
2432+ Array.isArray(child$jscomp$0)) &&
2433+ console.error(
2434+ "React expect children of <style> tags to be a string, number, or object with a `toString` method but found %s instead. In browsers style Elements can only have `Text` Nodes as children.",
2435+ "function" === typeof child$jscomp$0
2436+ ? "a Function"
2437+ : "symbol" === typeof child$jscomp$0
2438+ ? "a Sybmol"
2439+ : "an Array"
2440+ );
50622441 }
5063−
5064− update = update.next;
5065− } while (update !== null);
5066−
5067− workInProgressHook.memoizedState = newState;
5068− return [newState, dispatch];
5069− }
5070− }
5071−
5072− return [workInProgressHook.memoizedState, dispatch];
5073− } else {
5074− {
5075− isInHookUserCodeInDev = true;
5076− }
5077−
5078− var initialState;
5079−
5080− if (reducer === basicStateReducer) {
5081− // Special case for `useState`.
5082− initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
5083− } else {
5084− initialState = init !== undefined ? init(initialArg) : initialArg;
5085− }
5086−
5087− {
5088− isInHookUserCodeInDev = false;
5089− }
5090−
5091− workInProgressHook.memoizedState = initialState;
5092−
5093− var _queue = workInProgressHook.queue = {
5094− last: null,
5095− dispatch: null
5096− };
5097−
5098− var _dispatch = _queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, _queue);
5099−
5100− return [workInProgressHook.memoizedState, _dispatch];
5101− }
5102−}
5103−
5104−function useMemo(nextCreate, deps) {
5105− currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
5106− workInProgressHook = createWorkInProgressHook();
5107− var nextDeps = deps === undefined ? null : deps;
5108−
5109− if (workInProgressHook !== null) {
5110− var prevState = workInProgressHook.memoizedState;
5111−
5112− if (prevState !== null) {
5113− if (nextDeps !== null) {
5114− var prevDeps = prevState[1];
5115−
5116− if (areHookInputsEqual(nextDeps, prevDeps)) {
5117− return prevState[0];
5118− }
5119− }
5120− }
5121− }
5122−
5123− {
5124− isInHookUserCodeInDev = true;
5125− }
5126−
5127− var nextValue = nextCreate();
5128−
5129− {
5130− isInHookUserCodeInDev = false;
5131− }
5132−
5133− workInProgressHook.memoizedState = [nextValue, nextDeps];
5134− return nextValue;
5135−}
5136−
5137−function useRef(initialValue) {
5138− currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
5139− workInProgressHook = createWorkInProgressHook();
5140− var previousRef = workInProgressHook.memoizedState;
5141−
5142− if (previousRef === null) {
5143− var ref = {
5144− current: initialValue
5145− };
5146−
5147− {
5148− Object.seal(ref);
5149− }
5150−
5151− workInProgressHook.memoizedState = ref;
5152− return ref;
5153− } else {
5154− return previousRef;
5155− }
5156−}
5157−
5158−function useLayoutEffect(create, inputs) {
5159− {
5160− currentHookNameInDev = 'useLayoutEffect';
5161−
5162− error('useLayoutEffect does nothing on the server, because its effect cannot ' + "be encoded into the server renderer's output format. This will lead " + 'to a mismatch between the initial, non-hydrated UI and the intended ' + 'UI. To avoid this, useLayoutEffect should only be used in ' + 'components that render exclusively on the client. ' + 'See https://reactjs.org/link/uselayouteffect-ssr for common fixes.');
5163− }
5164−}
5165−
5166−function dispatchAction(componentIdentity, queue, action) {
5167− if (numberOfReRenders >= RE_RENDER_LIMIT) {
5168− throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
5169− }
5170−
5171− if (componentIdentity === currentlyRenderingComponent) {
5172− // This is a render phase update. Stash it in a lazily-created map of
5173− // queue -> linked list of updates. After this render pass, we'll restart
5174− // and apply the stashed updates on top of the work-in-progress hook.
5175− didScheduleRenderPhaseUpdate = true;
5176− var update = {
5177− action: action,
5178− next: null
5179− };
5180−
5181− if (renderPhaseUpdates === null) {
5182− renderPhaseUpdates = new Map();
5183− }
5184−
5185− var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
5186−
5187− if (firstRenderPhaseUpdate === undefined) {
5188− renderPhaseUpdates.set(queue, update);
5189− } else {
5190− // Append the update to the end of the list.
5191− var lastRenderPhaseUpdate = firstRenderPhaseUpdate;
5192−
5193− while (lastRenderPhaseUpdate.next !== null) {
5194− lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
5195− }
5196−
5197− lastRenderPhaseUpdate.next = update;
5198− }
5199− }
5200−}
5201−
5202−function useCallback(callback, deps) {
5203− return useMemo(function () {
5204− return callback;
5205− }, deps);
5206−} // TODO Decide on how to implement this hook for server rendering.
5207−// If a mutation occurs during render, consider triggering a Suspense boundary
5208−// and falling back to client rendering.
5209−
5210−function useMutableSource(source, getSnapshot, subscribe) {
5211− resolveCurrentlyRenderingComponent();
5212− return getSnapshot(source._source);
5213−}
5214−
5215−function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
5216− if (getServerSnapshot === undefined) {
5217− throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
5218− }
5219−
5220− return getServerSnapshot();
5221−}
5222−
5223−function useDeferredValue(value) {
5224− resolveCurrentlyRenderingComponent();
5225− return value;
5226−}
5227−
5228−function unsupportedStartTransition() {
5229− throw new Error('startTransition cannot be called during server rendering.');
5230−}
5231−
5232−function useTransition() {
5233− resolveCurrentlyRenderingComponent();
5234− return [false, unsupportedStartTransition];
5235−}
5236−
5237−function useId() {
5238− var task = currentlyRenderingTask;
5239− var treeId = getTreeId(task.treeContext);
5240− var responseState = currentResponseState;
5241−
5242− if (responseState === null) {
5243− throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
5244− }
5245−
5246− var localId = localIdCounter++;
5247− return makeId(responseState, treeId, localId);
5248−}
5249−
5250−function noop() {}
5251−
5252−var Dispatcher = {
5253− readContext: readContext$1,
5254− useContext: useContext,
5255− useMemo: useMemo,
5256− useReducer: useReducer,
5257− useRef: useRef,
5258− useState: useState,
5259− useInsertionEffect: noop,
5260− useLayoutEffect: useLayoutEffect,
5261− useCallback: useCallback,
5262− // useImperativeHandle is not run in the server environment
5263− useImperativeHandle: noop,
5264− // Effects are not run in the server environment.
5265− useEffect: noop,
5266− // Debugging effect
5267− useDebugValue: noop,
5268− useDeferredValue: useDeferredValue,
5269− useTransition: useTransition,
5270− useId: useId,
5271− // Subscriptions are not setup in a server environment.
5272− useMutableSource: useMutableSource,
5273− useSyncExternalStore: useSyncExternalStore
5274−};
5275−
5276−var currentResponseState = null;
5277−function setCurrentResponseState(responseState) {
5278− currentResponseState = responseState;
5279−}
5280−
5281−function getStackByComponentStackNode(componentStack) {
5282− try {
5283− var info = '';
5284− var node = componentStack;
5285−
5286− do {
5287− switch (node.tag) {
5288− case 0:
5289− info += describeBuiltInComponentFrame(node.type, null, null);
5290− break;
5291−
5292− case 1:
5293− info += describeFunctionComponentFrame(node.type, null, null);
5294− break;
5295−
5296− case 2:
5297− info += describeClassComponentFrame(node.type, null, null);
2442+ var precedence$jscomp$0 = props.precedence,
2443+ href$jscomp$0 = props.href,
2444+ nonce = props.nonce;
2445+ if (
2446+ formatContext.insertionMode === SVG_MODE ||
2447+ noscriptTagInScope$jscomp$2 ||
2448+ null != props.itemProp ||
2449+ "string" !== typeof precedence$jscomp$0 ||
2450+ "string" !== typeof href$jscomp$0 ||
2451+ "" === href$jscomp$0
2452+ ) {
2453+ target$jscomp$0.push(startChunkForTag("style"));
2454+ var children$jscomp$8 = null,
2455+ innerHTML$jscomp$5 = null,
2456+ propKey$jscomp$8;
2457+ for (propKey$jscomp$8 in props)
2458+ if (hasOwnProperty.call(props, propKey$jscomp$8)) {
2459+ var propValue$jscomp$8 = props[propKey$jscomp$8];
2460+ if (null != propValue$jscomp$8)
2461+ switch (propKey$jscomp$8) {
2462+ case "children":
2463+ children$jscomp$8 = propValue$jscomp$8;
2464+ break;
2465+ case "dangerouslySetInnerHTML":
2466+ innerHTML$jscomp$5 = propValue$jscomp$8;
2467+ break;
2468+ default:
2469+ pushAttribute(
2470+ target$jscomp$0,
2471+ propKey$jscomp$8,
2472+ propValue$jscomp$8
2473+ );
2474+ }
2475+ }
2476+ target$jscomp$0.push(endOfStartTag);
2477+ var child$jscomp$1 = Array.isArray(children$jscomp$8)
2478+ ? 2 > children$jscomp$8.length
2479+ ? children$jscomp$8[0]
2480+ : null
2481+ : children$jscomp$8;
2482+ "function" !== typeof child$jscomp$1 &&
2483+ "symbol" !== typeof child$jscomp$1 &&
2484+ null !== child$jscomp$1 &&
2485+ void 0 !== child$jscomp$1 &&
2486+ target$jscomp$0.push(escapeStyleTextContent(child$jscomp$1));
2487+ pushInnerHTML(
2488+ target$jscomp$0,
2489+ innerHTML$jscomp$5,
2490+ children$jscomp$8
2491+ );
2492+ target$jscomp$0.push(endChunkForTag("style"));
2493+ var JSCompiler_inline_result$jscomp$7 = null;
2494+ } else {
2495+ href$jscomp$0.includes(" ") &&
2496+ console.error(
2497+ 'React expected the `href` prop for a <style> tag opting into hoisting semantics using the `precedence` prop to not have any spaces but ecountered spaces instead. using spaces in this prop will cause hydration of this style to fail on the client. The href for the <style> where this ocurred is "%s".',
2498+ href$jscomp$0
2499+ );
2500+ var styleQueue$jscomp$0 =
2501+ renderState.styles.get(precedence$jscomp$0),
2502+ resourceState$jscomp$1 =
2503+ resumableState.styleResources.hasOwnProperty(href$jscomp$0)
2504+ ? resumableState.styleResources[href$jscomp$0]
2505+ : void 0;
2506+ if (resourceState$jscomp$1 !== EXISTS) {
2507+ resumableState.styleResources[href$jscomp$0] = EXISTS;
2508+ resourceState$jscomp$1 &&
2509+ console.error(
2510+ 'React encountered a hoistable style tag for the same href as a preload: "%s". When using a style tag to inline styles you should not also preload it as a stylsheet.',
2511+ href$jscomp$0
2512+ );
2513+ styleQueue$jscomp$0 ||
2514+ ((styleQueue$jscomp$0 = {
2515+ precedence: escapeTextForBrowser(precedence$jscomp$0),
2516+ rules: [],
2517+ hrefs: [],
2518+ sheets: new Map()
2519+ }),
2520+ renderState.styles.set(
2521+ precedence$jscomp$0,
2522+ styleQueue$jscomp$0
2523+ ));
2524+ var nonceStyle = renderState.nonce.style;
2525+ if (nonceStyle && nonceStyle !== nonce)
2526+ console.error(
2527+ 'React encountered a style tag with `precedence` "%s" and `nonce` "%s". When React manages style rules using `precedence` it will only include rules if the nonce matches the style nonce "%s" that was included with this render.',
2528+ precedence$jscomp$0,
2529+ nonce,
2530+ nonceStyle
2531+ );
2532+ else {
2533+ !nonceStyle &&
2534+ nonce &&
2535+ console.error(
2536+ 'React encountered a style tag with `precedence` "%s" and `nonce` "%s". When React manages style rules using `precedence` it will only include a nonce attributes if you also provide the same style nonce value as a render option.',
2537+ precedence$jscomp$0,
2538+ nonce
2539+ );
2540+ styleQueue$jscomp$0.hrefs.push(
2541+ escapeTextForBrowser(href$jscomp$0)
2542+ );
2543+ var target = styleQueue$jscomp$0.rules,
2544+ children$jscomp$9 = null,
2545+ innerHTML$jscomp$6 = null,
2546+ propKey$jscomp$9;
2547+ for (propKey$jscomp$9 in props)
2548+ if (hasOwnProperty.call(props, propKey$jscomp$9)) {
2549+ var propValue$jscomp$9 = props[propKey$jscomp$9];
2550+ if (null != propValue$jscomp$9)
2551+ switch (propKey$jscomp$9) {
2552+ case "children":
2553+ children$jscomp$9 = propValue$jscomp$9;
2554+ break;
2555+ case "dangerouslySetInnerHTML":
2556+ innerHTML$jscomp$6 = propValue$jscomp$9;
2557+ }
2558+ }
2559+ var child$jscomp$2 = Array.isArray(children$jscomp$9)
2560+ ? 2 > children$jscomp$9.length
2561+ ? children$jscomp$9[0]
2562+ : null
2563+ : children$jscomp$9;
2564+ "function" !== typeof child$jscomp$2 &&
2565+ "symbol" !== typeof child$jscomp$2 &&
2566+ null !== child$jscomp$2 &&
2567+ void 0 !== child$jscomp$2 &&
2568+ target.push(escapeStyleTextContent(child$jscomp$2));
2569+ pushInnerHTML(target, innerHTML$jscomp$6, children$jscomp$9);
2570+ }
2571+ }
2572+ styleQueue$jscomp$0 &&
2573+ hoistableState &&
2574+ hoistableState.styles.add(styleQueue$jscomp$0);
2575+ textEmbedded && target$jscomp$0.push("\x3c!-- --\x3e");
2576+ JSCompiler_inline_result$jscomp$7 = void 0;
2577+ }
2578+ return JSCompiler_inline_result$jscomp$7;
2579+ case "meta":
2580+ var noscriptTagInScope$jscomp$3 = formatContext.tagScope & 1,
2581+ isFallback$jscomp$1 = formatContext.tagScope & 4;
2582+ if (
2583+ formatContext.insertionMode === SVG_MODE ||
2584+ noscriptTagInScope$jscomp$3 ||
2585+ null != props.itemProp
2586+ )
2587+ var JSCompiler_inline_result$jscomp$8 = pushSelfClosing(
2588+ target$jscomp$0,
2589+ props,
2590+ "meta"
2591+ );
2592+ else
2593+ textEmbedded && target$jscomp$0.push("\x3c!-- --\x3e"),
2594+ (JSCompiler_inline_result$jscomp$8 = isFallback$jscomp$1
2595+ ? null
2596+ : "string" === typeof props.charSet
2597+ ? pushSelfClosing(renderState.charsetChunks, props, "meta")
2598+ : "viewport" === props.name
2599+ ? pushSelfClosing(renderState.viewportChunks, props, "meta")
2600+ : pushSelfClosing(
2601+ renderState.hoistableChunks,
2602+ props,
2603+ "meta"
2604+ ));
2605+ return JSCompiler_inline_result$jscomp$8;
2606+ case "listing":
2607+ case "pre":
2608+ target$jscomp$0.push(startChunkForTag(type));
2609+ var children$jscomp$10 = null,
2610+ innerHTML$jscomp$7 = null,
2611+ propKey$jscomp$10;
2612+ for (propKey$jscomp$10 in props)
2613+ if (hasOwnProperty.call(props, propKey$jscomp$10)) {
2614+ var propValue$jscomp$10 = props[propKey$jscomp$10];
2615+ if (null != propValue$jscomp$10)
2616+ switch (propKey$jscomp$10) {
2617+ case "children":
2618+ children$jscomp$10 = propValue$jscomp$10;
2619+ break;
2620+ case "dangerouslySetInnerHTML":
2621+ innerHTML$jscomp$7 = propValue$jscomp$10;
2622+ break;
2623+ default:
2624+ pushAttribute(
2625+ target$jscomp$0,
2626+ propKey$jscomp$10,
2627+ propValue$jscomp$10
2628+ );
2629+ }
2630+ }
2631+ target$jscomp$0.push(endOfStartTag);
2632+ if (null != innerHTML$jscomp$7) {
2633+ if (null != children$jscomp$10)
2634+ throw Error(
2635+ "Can only set one of `children` or `props.dangerouslySetInnerHTML`."
2636+ );
2637+ if (
2638+ "object" !== typeof innerHTML$jscomp$7 ||
2639+ !("__html" in innerHTML$jscomp$7)
2640+ )
2641+ throw Error(
2642+ "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://react.dev/link/dangerously-set-inner-html for more information."
2643+ );
2644+ var html = innerHTML$jscomp$7.__html;
2645+ null !== html &&
2646+ void 0 !== html &&
2647+ ("string" === typeof html && 0 < html.length && "\n" === html[0]
2648+ ? target$jscomp$0.push(leadingNewline, html)
2649+ : (checkHtmlStringCoercion(html),
2650+ target$jscomp$0.push("" + html)));
2651+ }
2652+ "string" === typeof children$jscomp$10 &&
2653+ "\n" === children$jscomp$10[0] &&
2654+ target$jscomp$0.push(leadingNewline);
2655+ return children$jscomp$10;
2656+ case "img":
2657+ var pictureOrNoScriptTagInScope = formatContext.tagScope & 3,
2658+ src = props.src,
2659+ srcSet = props.srcSet;
2660+ if (
2661+ !(
2662+ "lazy" === props.loading ||
2663+ (!src && !srcSet) ||
2664+ ("string" !== typeof src && null != src) ||
2665+ ("string" !== typeof srcSet && null != srcSet) ||
2666+ "low" === props.fetchPriority ||
2667+ pictureOrNoScriptTagInScope
2668+ ) &&
2669+ ("string" !== typeof src ||
2670+ ":" !== src[4] ||
2671+ ("d" !== src[0] && "D" !== src[0]) ||
2672+ ("a" !== src[1] && "A" !== src[1]) ||
2673+ ("t" !== src[2] && "T" !== src[2]) ||
2674+ ("a" !== src[3] && "A" !== src[3])) &&
2675+ ("string" !== typeof srcSet ||
2676+ ":" !== srcSet[4] ||
2677+ ("d" !== srcSet[0] && "D" !== srcSet[0]) ||
2678+ ("a" !== srcSet[1] && "A" !== srcSet[1]) ||
2679+ ("t" !== srcSet[2] && "T" !== srcSet[2]) ||
2680+ ("a" !== srcSet[3] && "A" !== srcSet[3]))
2681+ ) {
2682+ null !== hoistableState &&
2683+ formatContext.tagScope & 64 &&
2684+ (hoistableState.suspenseyImages = !0);
2685+ var sizes = "string" === typeof props.sizes ? props.sizes : void 0,
2686+ key$jscomp$0 = srcSet ? srcSet + "\n" + (sizes || "") : src,
2687+ promotablePreloads = renderState.preloads.images,
2688+ resource$jscomp$1 = promotablePreloads.get(key$jscomp$0);
2689+ if (resource$jscomp$1) {
2690+ if (
2691+ "high" === props.fetchPriority ||
2692+ 10 > renderState.highImagePreloads.size
2693+ )
2694+ promotablePreloads.delete(key$jscomp$0),
2695+ renderState.highImagePreloads.add(resource$jscomp$1);
2696+ } else if (
2697+ !resumableState.imageResources.hasOwnProperty(key$jscomp$0)
2698+ ) {
2699+ resumableState.imageResources[key$jscomp$0] = PRELOAD_NO_CREDS;
2700+ var input = props.crossOrigin;
2701+ var crossOrigin =
2702+ "string" === typeof input
2703+ ? "use-credentials" === input
2704+ ? input
2705+ : ""
2706+ : void 0;
2707+ var headers = renderState.headers,
2708+ header;
2709+ headers &&
2710+ 0 < headers.remainingCapacity &&
2711+ "string" !== typeof props.srcSet &&
2712+ ("high" === props.fetchPriority ||
2713+ 500 > headers.highImagePreloads.length) &&
2714+ ((header = getPreloadAsHeader(src, "image", {
2715+ imageSrcSet: props.srcSet,
2716+ imageSizes: props.sizes,
2717+ crossOrigin: crossOrigin,
2718+ integrity: props.integrity,
2719+ nonce: props.nonce,
2720+ type: props.type,
2721+ fetchPriority: props.fetchPriority,
2722+ referrerPolicy: props.refererPolicy
2723+ })),
2724+ 0 <= (headers.remainingCapacity -= header.length + 2))
2725+ ? ((renderState.resets.image[key$jscomp$0] = PRELOAD_NO_CREDS),
2726+ headers.highImagePreloads &&
2727+ (headers.highImagePreloads += ", "),
2728+ (headers.highImagePreloads += header))
2729+ : ((resource$jscomp$1 = []),
2730+ pushLinkImpl(resource$jscomp$1, {
2731+ rel: "preload",
2732+ as: "image",
2733+ href: srcSet ? void 0 : src,
2734+ imageSrcSet: srcSet,
2735+ imageSizes: sizes,
2736+ crossOrigin: crossOrigin,
2737+ integrity: props.integrity,
2738+ type: props.type,
2739+ fetchPriority: props.fetchPriority,
2740+ referrerPolicy: props.referrerPolicy
2741+ }),
2742+ "high" === props.fetchPriority ||
2743+ 10 > renderState.highImagePreloads.size
2744+ ? renderState.highImagePreloads.add(resource$jscomp$1)
2745+ : (renderState.bulkPreloads.add(resource$jscomp$1),
2746+ promotablePreloads.set(key$jscomp$0, resource$jscomp$1)));
2747+ }
2748+ }
2749+ return pushSelfClosing(target$jscomp$0, props, "img");
2750+ case "base":
2751+ case "area":
2752+ case "br":
2753+ case "col":
2754+ case "embed":
2755+ case "hr":
2756+ case "keygen":
2757+ case "param":
2758+ case "source":
2759+ case "track":
2760+ case "wbr":
2761+ return pushSelfClosing(target$jscomp$0, props, type);
2762+ case "annotation-xml":
2763+ case "color-profile":
2764+ case "font-face":
2765+ case "font-face-src":
2766+ case "font-face-uri":
2767+ case "font-face-format":
2768+ case "font-face-name":
2769+ case "missing-glyph":
52982770 break;
2771+ case "head":
2772+ if (formatContext.insertionMode < HTML_MODE) {
2773+ var preamble = preambleState || renderState.preamble;
2774+ if (preamble.headChunks)
2775+ throw Error("The `<head>` tag may only be rendered once.");
2776+ null !== preambleState && target$jscomp$0.push("\x3c!--head--\x3e");
2777+ preamble.headChunks = [];
2778+ var JSCompiler_inline_result$jscomp$9 = pushStartSingletonElement(
2779+ preamble.headChunks,
2780+ props,
2781+ "head"
2782+ );
2783+ } else
2784+ JSCompiler_inline_result$jscomp$9 = pushStartGenericElement(
2785+ target$jscomp$0,
2786+ props,
2787+ "head"
2788+ );
2789+ return JSCompiler_inline_result$jscomp$9;
2790+ case "body":
2791+ if (formatContext.insertionMode < HTML_MODE) {
2792+ var preamble$jscomp$0 = preambleState || renderState.preamble;
2793+ if (preamble$jscomp$0.bodyChunks)
2794+ throw Error("The `<body>` tag may only be rendered once.");
2795+ null !== preambleState && target$jscomp$0.push("\x3c!--body--\x3e");
2796+ preamble$jscomp$0.bodyChunks = [];
2797+ var JSCompiler_inline_result$jscomp$10 = pushStartSingletonElement(
2798+ preamble$jscomp$0.bodyChunks,
2799+ props,
2800+ "body"
2801+ );
2802+ } else
2803+ JSCompiler_inline_result$jscomp$10 = pushStartGenericElement(
2804+ target$jscomp$0,
2805+ props,
2806+ "body"
2807+ );
2808+ return JSCompiler_inline_result$jscomp$10;
2809+ case "html":
2810+ if (formatContext.insertionMode === ROOT_HTML_MODE) {
2811+ var preamble$jscomp$1 = preambleState || renderState.preamble;
2812+ if (preamble$jscomp$1.htmlChunks)
2813+ throw Error("The `<html>` tag may only be rendered once.");
2814+ null !== preambleState && target$jscomp$0.push("\x3c!--html--\x3e");
2815+ preamble$jscomp$1.htmlChunks = [doctypeChunk];
2816+ var JSCompiler_inline_result$jscomp$11 = pushStartSingletonElement(
2817+ preamble$jscomp$1.htmlChunks,
2818+ props,
2819+ "html"
2820+ );
2821+ } else
2822+ JSCompiler_inline_result$jscomp$11 = pushStartGenericElement(
2823+ target$jscomp$0,
2824+ props,
2825+ "html"
2826+ );
2827+ return JSCompiler_inline_result$jscomp$11;
2828+ default:
2829+ if (-1 !== type.indexOf("-")) {
2830+ target$jscomp$0.push(startChunkForTag(type));
2831+ var children$jscomp$11 = null,
2832+ innerHTML$jscomp$8 = null,
2833+ propKey$jscomp$11;
2834+ for (propKey$jscomp$11 in props)
2835+ if (hasOwnProperty.call(props, propKey$jscomp$11)) {
2836+ var propValue$jscomp$11 = props[propKey$jscomp$11];
2837+ if (null != propValue$jscomp$11) {
2838+ var attributeName = propKey$jscomp$11;
2839+ switch (propKey$jscomp$11) {
2840+ case "children":
2841+ children$jscomp$11 = propValue$jscomp$11;
2842+ break;
2843+ case "dangerouslySetInnerHTML":
2844+ innerHTML$jscomp$8 = propValue$jscomp$11;
2845+ break;
2846+ case "style":
2847+ pushStyleAttribute(target$jscomp$0, propValue$jscomp$11);
2848+ break;
2849+ case "suppressContentEditableWarning":
2850+ case "suppressHydrationWarning":
2851+ case "ref":
2852+ break;
2853+ case "className":
2854+ attributeName = "class";
2855+ default:
2856+ if (
2857+ isAttributeNameSafe(propKey$jscomp$11) &&
2858+ "function" !== typeof propValue$jscomp$11 &&
2859+ "symbol" !== typeof propValue$jscomp$11 &&
2860+ !1 !== propValue$jscomp$11
2861+ ) {
2862+ if (!0 === propValue$jscomp$11)
2863+ propValue$jscomp$11 = "";
2864+ else if ("object" === typeof propValue$jscomp$11)
2865+ continue;
2866+ target$jscomp$0.push(
2867+ attributeSeparator,
2868+ attributeName,
2869+ attributeAssign,
2870+ escapeTextForBrowser(propValue$jscomp$11),
2871+ attributeEnd
2872+ );
2873+ }
2874+ }
2875+ }
2876+ }
2877+ target$jscomp$0.push(endOfStartTag);
2878+ pushInnerHTML(
2879+ target$jscomp$0,
2880+ innerHTML$jscomp$8,
2881+ children$jscomp$11
2882+ );
2883+ return children$jscomp$11;
2884+ }
52992885 }
5300−
5301− node = node.parent;
5302− } while (node);
5303−
5304− return info;
5305− } catch (x) {
5306− return '\nError generating stack: ' + x.message + '\n' + x.stack;
5307− }
5308−}
5309−
5310−var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
5311−var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
5312−var PENDING = 0;
5313−var COMPLETED = 1;
5314−var FLUSHED = 2;
5315−var ABORTED = 3;
5316−var ERRORED = 4;
5317−var OPEN = 0;
5318−var CLOSING = 1;
5319−var CLOSED = 2;
5320−// This is a default heuristic for how to split up the HTML content into progressive
5321−// loading. Our goal is to be able to display additional new content about every 500ms.
5322−// Faster than that is unnecessary and should be throttled on the client. It also
5323−// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
5324−// end device but higher end suffer less from the overhead than lower end does from
5325−// not getting small enough pieces. We error on the side of low end.
5326−// We base this on low end 3G speeds which is about 500kbits per second. We assume
5327−// that there can be a reasonable drop off from max bandwidth which leaves you with
5328−// as little as 80%. We can receive half of that each 500ms - at best. In practice,
5329−// a little bandwidth is lost to processing and contention - e.g. CSS and images that
5330−// are downloaded along with the main content. So we estimate about half of that to be
5331−// the lower end throughput. In other words, we expect that you can at least show
5332−// about 12.5kb of content per 500ms. Not counting starting latency for the first
5333−// paint.
5334−// 500 * 1024 / 8 * .8 * 0.5 / 2
5335−var DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
5336−
5337−function defaultErrorHandler(error) {
5338− console['error'](error); // Don't transform to our wrapper
5339−
5340− return null;
5341−}
5342−
5343−function noop$1() {}
5344−
5345−function createRequest(children, responseState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError) {
5346− var pingedTasks = [];
5347− var abortSet = new Set();
5348− var request = {
5349− destination: null,
5350− responseState: responseState,
5351− progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
5352− status: OPEN,
5353− fatalError: null,
5354− nextSegmentId: 0,
5355− allPendingTasks: 0,
5356− pendingRootTasks: 0,
5357− completedRootSegment: null,
5358− abortableTasks: abortSet,
5359− pingedTasks: pingedTasks,
5360− clientRenderedBoundaries: [],
5361− completedBoundaries: [],
5362− partialBoundaries: [],
5363− onError: onError === undefined ? defaultErrorHandler : onError,
5364− onAllReady: onAllReady === undefined ? noop$1 : onAllReady,
5365− onShellReady: onShellReady === undefined ? noop$1 : onShellReady,
5366− onShellError: onShellError === undefined ? noop$1 : onShellError,
5367− onFatalError: onFatalError === undefined ? noop$1 : onFatalError
5368− }; // This segment represents the root fallback.
5369−
5370− var rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
5371− false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
5372−
5373− rootSegment.parentFlushed = true;
5374− var rootTask = createTask(request, children, null, rootSegment, abortSet, emptyContextObject, rootContextSnapshot, emptyTreeContext);
5375− pingedTasks.push(rootTask);
5376− return request;
5377−}
5378−
5379−function pingTask(request, task) {
5380− var pingedTasks = request.pingedTasks;
5381− pingedTasks.push(task);
5382−
5383− if (pingedTasks.length === 1) {
5384− scheduleWork(function () {
5385− return performWork(request);
5386− });
5387− }
5388−}
5389−
5390−function createSuspenseBoundary(request, fallbackAbortableTasks) {
5391− return {
5392− id: UNINITIALIZED_SUSPENSE_BOUNDARY_ID,
5393− rootSegmentID: -1,
5394− parentFlushed: false,
5395− pendingTasks: 0,
5396− forceClientRender: false,
5397− completedSegments: [],
5398− byteSize: 0,
5399− fallbackAbortableTasks: fallbackAbortableTasks,
5400− errorDigest: null
5401− };
5402−}
5403−
5404−function createTask(request, node, blockedBoundary, blockedSegment, abortSet, legacyContext, context, treeContext) {
5405− request.allPendingTasks++;
5406−
5407− if (blockedBoundary === null) {
5408− request.pendingRootTasks++;
5409− } else {
5410− blockedBoundary.pendingTasks++;
5411− }
5412−
5413− var task = {
5414− node: node,
5415− ping: function () {
5416− return pingTask(request, task);
5417− },
5418− blockedBoundary: blockedBoundary,
5419− blockedSegment: blockedSegment,
5420− abortSet: abortSet,
5421− legacyContext: legacyContext,
5422− context: context,
5423− treeContext: treeContext
5424− };
5425−
5426− {
5427− task.componentStack = null;
5428− }
5429−
5430− abortSet.add(task);
5431− return task;
5432−}
5433−
5434−function createPendingSegment(request, index, boundary, formatContext, lastPushedText, textEmbedded) {
5435− return {
5436− status: PENDING,
5437− id: -1,
5438− // lazily assigned later
5439− index: index,
5440− parentFlushed: false,
5441− chunks: [],
5442− children: [],
5443− formatContext: formatContext,
5444− boundary: boundary,
5445− lastPushedText: lastPushedText,
5446− textEmbedded: textEmbedded
5447− };
5448−} // DEV-only global reference to the currently executing task
5449−
5450−
5451−var currentTaskInDEV = null;
5452−
5453−function getCurrentStackInDEV() {
5454− {
5455− if (currentTaskInDEV === null || currentTaskInDEV.componentStack === null) {
5456− return '';
5457− }
5458−
5459− return getStackByComponentStackNode(currentTaskInDEV.componentStack);
5460− }
5461−}
5462−
5463−function pushBuiltInComponentStackInDEV(task, type) {
5464− {
5465− task.componentStack = {
5466− tag: 0,
5467− parent: task.componentStack,
5468− type: type
5469− };
5470− }
5471−}
5472−
5473−function pushFunctionComponentStackInDEV(task, type) {
5474− {
5475− task.componentStack = {
5476− tag: 1,
5477− parent: task.componentStack,
5478− type: type
5479− };
5480− }
5481−}
5482−
5483−function pushClassComponentStackInDEV(task, type) {
5484− {
5485− task.componentStack = {
5486− tag: 2,
5487− parent: task.componentStack,
5488− type: type
5489− };
5490− }
5491−}
5492−
5493−function popComponentStackInDEV(task) {
5494− {
5495− if (task.componentStack === null) {
5496− error('Unexpectedly popped too many stack frames. This is a bug in React.');
5497− } else {
5498− task.componentStack = task.componentStack.parent;
5499− }
5500− }
5501−} // stash the component stack of an unwinding error until it is processed
5502−
5503−
5504−var lastBoundaryErrorComponentStackDev = null;
5505−
5506−function captureBoundaryErrorDetailsDev(boundary, error) {
5507− {
5508− var errorMessage;
5509−
5510− if (typeof error === 'string') {
5511− errorMessage = error;
5512− } else if (error && typeof error.message === 'string') {
5513− errorMessage = error.message;
5514− } else {
5515− // eslint-disable-next-line react-internal/safe-string-coercion
5516− errorMessage = String(error);
5517− }
5518−
5519− var errorComponentStack = lastBoundaryErrorComponentStackDev || getCurrentStackInDEV();
5520− lastBoundaryErrorComponentStackDev = null;
5521− boundary.errorMessage = errorMessage;
5522− boundary.errorComponentStack = errorComponentStack;
5523− }
5524−}
5525−
5526−function logRecoverableError(request, error) {
5527− // If this callback errors, we intentionally let that error bubble up to become a fatal error
5528− // so that someone fixes the error reporting instead of hiding it.
5529− var errorDigest = request.onError(error);
5530−
5531− if (errorDigest != null && typeof errorDigest !== 'string') {
5532− // eslint-disable-next-line react-internal/prod-error-codes
5533− throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
5534− }
5535−
5536− return errorDigest;
5537−}
5538−
5539−function fatalError(request, error) {
5540− // This is called outside error handling code such as if the root errors outside
5541− // a suspense boundary or if the root suspense boundary's fallback errors.
5542− // It's also called if React itself or its host configs errors.
5543− var onShellError = request.onShellError;
5544− onShellError(error);
5545− var onFatalError = request.onFatalError;
5546− onFatalError(error);
5547−
5548− if (request.destination !== null) {
5549− request.status = CLOSED;
5550− closeWithError(request.destination, error);
5551− } else {
5552− request.status = CLOSING;
5553− request.fatalError = error;
5554− }
5555−}
5556−
5557−function renderSuspenseBoundary(request, task, props) {
5558− pushBuiltInComponentStackInDEV(task, 'Suspense');
5559− var parentBoundary = task.blockedBoundary;
5560− var parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
5561− // the fallback so that we can later replace that segment with the content.
5562− // This also lets us split out the main content even if it doesn't suspend,
5563− // in case it ends up generating a large subtree of content.
5564−
5565− var fallback = props.fallback;
5566− var content = props.children;
5567− var fallbackAbortSet = new Set();
5568− var newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
5569− var insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
5570−
5571− var boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, parentSegment.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
5572− false, false);
5573− parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
5574−
5575− parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
5576−
5577− var contentRootSegment = createPendingSegment(request, 0, null, parentSegment.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
5578− false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
5579− // no parent segment so there's nothing to wait on.
5580−
5581− contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
5582− // I suspect that there might be some efficiency benefits from not creating the suspended task
5583− // and instead just using the stack if possible.
5584− // TODO: Call this directly instead of messing with saving and restoring contexts.
5585− // We can reuse the current context and task to render the content immediately without
5586− // context switching. We just need to temporarily switch which boundary and which segment
5587− // we're writing to. If something suspends, it'll spawn new suspended task with that context.
5588−
5589− task.blockedBoundary = newBoundary;
5590− task.blockedSegment = contentRootSegment;
5591−
5592− try {
5593− // We use the safe form because we don't handle suspending here. Only error handling.
5594− renderNode(request, task, content);
5595− pushSegmentFinale$1(contentRootSegment.chunks, request.responseState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
5596− contentRootSegment.status = COMPLETED;
5597− queueCompletedSegment(newBoundary, contentRootSegment);
5598−
5599− if (newBoundary.pendingTasks === 0) {
5600− // This must have been the last segment we were waiting on. This boundary is now complete.
5601− // Therefore we won't need the fallback. We early return so that we don't have to create
5602− // the fallback.
5603− popComponentStackInDEV(task);
5604− return;
5605− }
5606− } catch (error) {
5607− contentRootSegment.status = ERRORED;
5608− newBoundary.forceClientRender = true;
5609− newBoundary.errorDigest = logRecoverableError(request, error);
5610−
5611− {
5612− captureBoundaryErrorDetailsDev(newBoundary, error);
5613− } // We don't need to decrement any task numbers because we didn't spawn any new task.
5614− // We don't need to schedule any task because we know the parent has written yet.
5615− // We do need to fallthrough to create the fallback though.
5616−
5617− } finally {
5618− task.blockedBoundary = parentBoundary;
5619− task.blockedSegment = parentSegment;
5620− } // We create suspended task for the fallback because we don't want to actually work
5621− // on it yet in case we finish the main content, so we queue for later.
5622−
5623−
5624− var suspendedFallbackTask = createTask(request, fallback, parentBoundary, boundarySegment, fallbackAbortSet, task.legacyContext, task.context, task.treeContext);
5625−
5626− {
5627− suspendedFallbackTask.componentStack = task.componentStack;
5628− } // TODO: This should be queued at a separate lower priority queue so that we only work
5629− // on preparing fallbacks if we don't have any more main content to task on.
5630−
5631−
5632− request.pingedTasks.push(suspendedFallbackTask);
5633− popComponentStackInDEV(task);
5634−}
5635−
5636−function renderHostElement(request, task, type, props) {
5637− pushBuiltInComponentStackInDEV(task, type);
5638− var segment = task.blockedSegment;
5639− var children = pushStartInstance(segment.chunks, type, props, request.responseState, segment.formatContext);
5640− segment.lastPushedText = false;
5641− var prevContext = segment.formatContext;
5642− segment.formatContext = getChildFormatContext(prevContext, type, props); // We use the non-destructive form because if something suspends, we still
5643− // need to pop back up and finish this subtree of HTML.
5644−
5645− renderNode(request, task, children); // We expect that errors will fatal the whole task and that we don't need
5646− // the correct context. Therefore this is not in a finally.
5647−
5648− segment.formatContext = prevContext;
5649− pushEndInstance(segment.chunks, type);
5650− segment.lastPushedText = false;
5651− popComponentStackInDEV(task);
5652−}
5653−
5654−function shouldConstruct$1(Component) {
5655− return Component.prototype && Component.prototype.isReactComponent;
5656−}
5657−
5658−function renderWithHooks(request, task, Component, props, secondArg) {
5659− var componentIdentity = {};
5660− prepareToUseHooks(task, componentIdentity);
5661− var result = Component(props, secondArg);
5662− return finishHooks(Component, props, result, secondArg);
5663−}
5664−
5665−function finishClassComponent(request, task, instance, Component, props) {
5666− var nextChildren = instance.render();
5667−
5668− {
5669− if (instance.props !== props) {
5670− if (!didWarnAboutReassigningProps) {
5671− error('It looks like %s is reassigning its own `this.props` while rendering. ' + 'This is not supported and can lead to confusing bugs.', getComponentNameFromType(Component) || 'a component');
5672− }
5673−
5674− didWarnAboutReassigningProps = true;
5675− }
5676− }
5677−
5678− {
5679− var childContextTypes = Component.childContextTypes;
5680−
5681− if (childContextTypes !== null && childContextTypes !== undefined) {
5682− var previousContext = task.legacyContext;
5683− var mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
5684− task.legacyContext = mergedContext;
5685− renderNodeDestructive(request, task, nextChildren);
5686− task.legacyContext = previousContext;
5687− return;
5688− }
5689− }
5690−
5691− renderNodeDestructive(request, task, nextChildren);
5692−}
5693−
5694−function renderClassComponent(request, task, Component, props) {
5695− pushClassComponentStackInDEV(task, Component);
5696− var maskedContext = getMaskedContext(Component, task.legacyContext) ;
5697− var instance = constructClassInstance(Component, props, maskedContext);
5698− mountClassInstance(instance, Component, props, maskedContext);
5699− finishClassComponent(request, task, instance, Component, props);
5700− popComponentStackInDEV(task);
5701−}
5702−
5703−var didWarnAboutBadClass = {};
5704−var didWarnAboutModulePatternComponent = {};
5705−var didWarnAboutContextTypeOnFunctionComponent = {};
5706−var didWarnAboutGetDerivedStateOnFunctionComponent = {};
5707−var didWarnAboutReassigningProps = false;
5708−var didWarnAboutDefaultPropsOnFunctionComponent = {};
5709−var didWarnAboutGenerators = false;
5710−var didWarnAboutMaps = false;
5711−var hasWarnedAboutUsingContextAsConsumer = false; // This would typically be a function component but we still support module pattern
5712−// components for some reason.
5713−
5714−function renderIndeterminateComponent(request, task, Component, props) {
5715− var legacyContext;
5716−
5717− {
5718− legacyContext = getMaskedContext(Component, task.legacyContext);
5719− }
5720−
5721− pushFunctionComponentStackInDEV(task, Component);
5722−
5723− {
5724− if (Component.prototype && typeof Component.prototype.render === 'function') {
5725− var componentName = getComponentNameFromType(Component) || 'Unknown';
5726−
5727− if (!didWarnAboutBadClass[componentName]) {
5728− error("The <%s /> component appears to have a render method, but doesn't extend React.Component. " + 'This is likely to cause errors. Change %s to extend React.Component instead.', componentName, componentName);
5729−
5730− didWarnAboutBadClass[componentName] = true;
5731− }
5732− }
5733− }
5734−
5735− var value = renderWithHooks(request, task, Component, props, legacyContext);
5736− var hasId = checkDidRenderIdHook();
5737−
5738− {
5739− // Support for module components is deprecated and is removed behind a flag.
5740− // Whether or not it would crash later, we want to show a good message in DEV first.
5741− if (typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
5742− var _componentName = getComponentNameFromType(Component) || 'Unknown';
5743−
5744− if (!didWarnAboutModulePatternComponent[_componentName]) {
5745− error('The <%s /> component appears to be a function component that returns a class instance. ' + 'Change %s to a class that extends React.Component instead. ' + "If you can't use a class try assigning the prototype on the function as a workaround. " + "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " + 'cannot be called with `new` by React.', _componentName, _componentName, _componentName);
5746−
5747− didWarnAboutModulePatternComponent[_componentName] = true;
5748− }
5749− }
5750− }
5751−
5752− if ( // Run these checks in production only if the flag is off.
5753− // Eventually we'll delete this branch altogether.
5754− typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
5755− {
5756− var _componentName2 = getComponentNameFromType(Component) || 'Unknown';
5757−
5758− if (!didWarnAboutModulePatternComponent[_componentName2]) {
5759− error('The <%s /> component appears to be a function component that returns a class instance. ' + 'Change %s to a class that extends React.Component instead. ' + "If you can't use a class try assigning the prototype on the function as a workaround. " + "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " + 'cannot be called with `new` by React.', _componentName2, _componentName2, _componentName2);
5760−
5761− didWarnAboutModulePatternComponent[_componentName2] = true;
5762− }
5763− }
5764−
5765− mountClassInstance(value, Component, props, legacyContext);
5766− finishClassComponent(request, task, value, Component, props);
5767− } else {
5768−
5769− {
5770− validateFunctionComponentInDev(Component);
5771− } // We're now successfully past this task, and we don't have to pop back to
5772− // the previous task every again, so we can use the destructive recursive form.
5773−
5774−
5775− if (hasId) {
5776− // This component materialized an id. We treat this as its own level, with
5777− // a single "child" slot.
5778− var prevTreeContext = task.treeContext;
5779− var totalChildren = 1;
5780− var index = 0;
5781− task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
5782−
5783− try {
5784− renderNodeDestructive(request, task, value);
5785− } finally {
5786− task.treeContext = prevTreeContext;
5787− }
5788− } else {
5789− renderNodeDestructive(request, task, value);
5790− }
5791− }
5792−
5793− popComponentStackInDEV(task);
5794−}
5795−
5796−function validateFunctionComponentInDev(Component) {
5797− {
5798− if (Component) {
5799− if (Component.childContextTypes) {
5800− error('%s(...): childContextTypes cannot be defined on a function component.', Component.displayName || Component.name || 'Component');
5801− }
5802− }
5803−
5804− if ( Component.defaultProps !== undefined) {
5805− var componentName = getComponentNameFromType(Component) || 'Unknown';
5806−
5807− if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
5808− error('%s: Support for defaultProps will be removed from function components ' + 'in a future major release. Use JavaScript default parameters instead.', componentName);
5809−
5810− didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
5811− }
5812− }
5813−
5814− if (typeof Component.getDerivedStateFromProps === 'function') {
5815− var _componentName3 = getComponentNameFromType(Component) || 'Unknown';
5816−
5817− if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
5818− error('%s: Function components do not support getDerivedStateFromProps.', _componentName3);
5819−
5820− didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
5821− }
5822− }
5823−
5824− if (typeof Component.contextType === 'object' && Component.contextType !== null) {
5825− var _componentName4 = getComponentNameFromType(Component) || 'Unknown';
5826−
5827− if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
5828− error('%s: Function components do not support contextType.', _componentName4);
5829−
5830− didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
5831− }
5832− }
5833− }
5834−}
5835−
5836−function resolveDefaultProps(Component, baseProps) {
5837− if (Component && Component.defaultProps) {
5838− // Resolve default props. Taken from ReactElement
5839− var props = assign({}, baseProps);
5840− var defaultProps = Component.defaultProps;
5841−
5842− for (var propName in defaultProps) {
5843− if (props[propName] === undefined) {
5844− props[propName] = defaultProps[propName];
5845− }
5846− }
5847−
5848− return props;
5849− }
5850−
5851− return baseProps;
5852−}
5853−
5854−function renderForwardRef(request, task, type, props, ref) {
5855− pushFunctionComponentStackInDEV(task, type.render);
5856− var children = renderWithHooks(request, task, type.render, props, ref);
5857− var hasId = checkDidRenderIdHook();
5858−
5859− if (hasId) {
5860− // This component materialized an id. We treat this as its own level, with
5861− // a single "child" slot.
5862− var prevTreeContext = task.treeContext;
5863− var totalChildren = 1;
5864− var index = 0;
5865− task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
5866−
5867− try {
5868− renderNodeDestructive(request, task, children);
5869− } finally {
5870− task.treeContext = prevTreeContext;
5871− }
5872− } else {
5873− renderNodeDestructive(request, task, children);
5874− }
5875−
5876− popComponentStackInDEV(task);
5877−}
5878−
5879−function renderMemo(request, task, type, props, ref) {
5880− var innerType = type.type;
5881− var resolvedProps = resolveDefaultProps(innerType, props);
5882− renderElement(request, task, innerType, resolvedProps, ref);
5883−}
5884−
5885−function renderContextConsumer(request, task, context, props) {
5886− // The logic below for Context differs depending on PROD or DEV mode. In
5887− // DEV mode, we create a separate object for Context.Consumer that acts
5888− // like a proxy to Context. This proxy object adds unnecessary code in PROD
5889− // so we use the old behaviour (Context.Consumer references Context) to
5890− // reduce size and overhead. The separate object references context via
5891− // a property called "_context", which also gives us the ability to check
5892− // in DEV mode if this property exists or not and warn if it does not.
5893− {
5894− if (context._context === undefined) {
5895− // This may be because it's a Context (rather than a Consumer).
5896− // Or it may be because it's older React where they're the same thing.
5897− // We only want to warn if we're sure it's a new React.
5898− if (context !== context.Consumer) {
5899− if (!hasWarnedAboutUsingContextAsConsumer) {
5900− hasWarnedAboutUsingContextAsConsumer = true;
5901−
5902− error('Rendering <Context> directly is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?');
5903− }
5904− }
5905− } else {
5906− context = context._context;
5907− }
5908− }
5909−
5910− var render = props.children;
5911−
5912− {
5913− if (typeof render !== 'function') {
5914− error('A context consumer was rendered with multiple children, or a child ' + "that isn't a function. A context consumer expects a single child " + 'that is a function. If you did pass a function, make sure there ' + 'is no trailing or leading whitespace around it.');
5915− }
5916− }
5917−
5918− var newValue = readContext(context);
5919− var newChildren = render(newValue);
5920− renderNodeDestructive(request, task, newChildren);
5921−}
5922−
5923−function renderContextProvider(request, task, type, props) {
5924− var context = type._context;
5925− var value = props.value;
5926− var children = props.children;
5927− var prevSnapshot;
5928−
5929− {
5930− prevSnapshot = task.context;
5931− }
5932−
5933− task.context = pushProvider(context, value);
5934− renderNodeDestructive(request, task, children);
5935− task.context = popProvider(context);
5936−
5937− {
5938− if (prevSnapshot !== task.context) {
5939− error('Popping the context provider did not return back to the original snapshot. This is a bug in React.');
5940− }
5941− }
5942−}
5943−
5944−function renderLazyComponent(request, task, lazyComponent, props, ref) {
5945− pushBuiltInComponentStackInDEV(task, 'Lazy');
5946− var payload = lazyComponent._payload;
5947− var init = lazyComponent._init;
5948− var Component = init(payload);
5949− var resolvedProps = resolveDefaultProps(Component, props);
5950− renderElement(request, task, Component, resolvedProps, ref);
5951− popComponentStackInDEV(task);
5952−}
5953−
5954−function renderElement(request, task, type, props, ref) {
5955− if (typeof type === 'function') {
5956− if (shouldConstruct$1(type)) {
5957− renderClassComponent(request, task, type, props);
5958− return;
5959− } else {
5960− renderIndeterminateComponent(request, task, type, props);
5961− return;
5962− }
5963− }
5964−
5965− if (typeof type === 'string') {
5966− renderHostElement(request, task, type, props);
5967− return;
5968− }
5969−
5970− switch (type) {
5971− // TODO: LegacyHidden acts the same as a fragment. This only works
5972− // because we currently assume that every instance of LegacyHidden is
5973− // accompanied by a host component wrapper. In the hidden mode, the host
5974− // component is given a `hidden` attribute, which ensures that the
5975− // initial HTML is not visible. To support the use of LegacyHidden as a
5976− // true fragment, without an extra DOM node, we would have to hide the
5977− // initial HTML in some other way.
5978− // TODO: Add REACT_OFFSCREEN_TYPE here too with the same capability.
5979− case REACT_LEGACY_HIDDEN_TYPE:
5980− case REACT_DEBUG_TRACING_MODE_TYPE:
5981− case REACT_STRICT_MODE_TYPE:
5982− case REACT_PROFILER_TYPE:
5983− case REACT_FRAGMENT_TYPE:
5984− {
5985− renderNodeDestructive(request, task, props.children);
5986− return;
5987− }
5988−
5989− case REACT_SUSPENSE_LIST_TYPE:
5990− {
5991− pushBuiltInComponentStackInDEV(task, 'SuspenseList'); // TODO: SuspenseList should control the boundaries.
5992−
5993− renderNodeDestructive(request, task, props.children);
5994− popComponentStackInDEV(task);
5995− return;
5996− }
5997−
5998− case REACT_SCOPE_TYPE:
5999− {
6000−
6001− throw new Error('ReactDOMServer does not yet support scope components.');
6002− }
6003− // eslint-disable-next-line-no-fallthrough
6004−
6005− case REACT_SUSPENSE_TYPE:
6006− {
6007− {
6008− renderSuspenseBoundary(request, task, props);
2886+ return pushStartGenericElement(target$jscomp$0, props, type);
2887+ }
2888+ function endChunkForTag(tag) {
2889+ var chunk = endTagCache.get(tag);
2890+ void 0 === chunk &&
2891+ ((chunk = "</" + tag + ">"), endTagCache.set(tag, chunk));
2892+ return chunk;
2893+ }
2894+ function hoistPreambleState(renderState, preambleState) {
2895+ renderState = renderState.preamble;
2896+ null === renderState.htmlChunks &&
2897+ preambleState.htmlChunks &&
2898+ (renderState.htmlChunks = preambleState.htmlChunks);
2899+ null === renderState.headChunks &&
2900+ preambleState.headChunks &&
2901+ (renderState.headChunks = preambleState.headChunks);
2902+ null === renderState.bodyChunks &&
2903+ preambleState.bodyChunks &&
2904+ (renderState.bodyChunks = preambleState.bodyChunks);
2905+ }
2906+ function writeBootstrap(destination, renderState) {
2907+ renderState = renderState.bootstrapChunks;
2908+ for (var i = 0; i < renderState.length - 1; i++)
2909+ destination.push(renderState[i]);
2910+ return i < renderState.length
2911+ ? ((i = renderState[i]), (renderState.length = 0), destination.push(i))
2912+ : !0;
2913+ }
2914+ function writeStartPendingSuspenseBoundary(destination, renderState, id) {
2915+ destination.push(startPendingSuspenseBoundary1);
2916+ if (null === id)
2917+ throw Error(
2918+ "An ID must have been assigned before we can complete the boundary."
2919+ );
2920+ destination.push(renderState.boundaryPrefix);
2921+ renderState = id.toString(16);
2922+ destination.push(renderState);
2923+ return destination.push(startPendingSuspenseBoundary2);
2924+ }
2925+ function writeStartSegment(destination, renderState, formatContext, id) {
2926+ switch (formatContext.insertionMode) {
2927+ case ROOT_HTML_MODE:
2928+ case HTML_HTML_MODE:
2929+ case HTML_HEAD_MODE:
2930+ case HTML_MODE:
2931+ return (
2932+ destination.push(startSegmentHTML),
2933+ destination.push(renderState.segmentPrefix),
2934+ (renderState = id.toString(16)),
2935+ destination.push(renderState),
2936+ destination.push(startSegmentHTML2)
2937+ );
2938+ case SVG_MODE:
2939+ return (
2940+ destination.push(startSegmentSVG),
2941+ destination.push(renderState.segmentPrefix),
2942+ (renderState = id.toString(16)),
2943+ destination.push(renderState),
2944+ destination.push(startSegmentSVG2)
2945+ );
2946+ case MATHML_MODE:
2947+ return (
2948+ destination.push(startSegmentMathML),
2949+ destination.push(renderState.segmentPrefix),
2950+ (renderState = id.toString(16)),
2951+ destination.push(renderState),
2952+ destination.push(startSegmentMathML2)
2953+ );
2954+ case HTML_TABLE_MODE:
2955+ return (
2956+ destination.push(startSegmentTable),
2957+ destination.push(renderState.segmentPrefix),
2958+ (renderState = id.toString(16)),
2959+ destination.push(renderState),
2960+ destination.push(startSegmentTable2)
2961+ );
2962+ case HTML_TABLE_BODY_MODE:
2963+ return (
2964+ destination.push(startSegmentTableBody),
2965+ destination.push(renderState.segmentPrefix),
2966+ (renderState = id.toString(16)),
2967+ destination.push(renderState),
2968+ destination.push(startSegmentTableBody2)
2969+ );
2970+ case HTML_TABLE_ROW_MODE:
2971+ return (
2972+ destination.push(startSegmentTableRow),
2973+ destination.push(renderState.segmentPrefix),
2974+ (renderState = id.toString(16)),
2975+ destination.push(renderState),
2976+ destination.push(startSegmentTableRow2)
2977+ );
2978+ case HTML_COLGROUP_MODE:
2979+ return (
2980+ destination.push(startSegmentColGroup),
2981+ destination.push(renderState.segmentPrefix),
2982+ (renderState = id.toString(16)),
2983+ destination.push(renderState),
2984+ destination.push(startSegmentColGroup2)
2985+ );
2986+ default:
2987+ throw Error("Unknown insertion mode. This is a bug in React.");
2988+ }
2989+ }
2990+ function writeEndSegment(destination, formatContext) {
2991+ switch (formatContext.insertionMode) {
2992+ case ROOT_HTML_MODE:
2993+ case HTML_HTML_MODE:
2994+ case HTML_HEAD_MODE:
2995+ case HTML_MODE:
2996+ return destination.push(endSegmentHTML);
2997+ case SVG_MODE:
2998+ return destination.push(endSegmentSVG);
2999+ case MATHML_MODE:
3000+ return destination.push(endSegmentMathML);
3001+ case HTML_TABLE_MODE:
3002+ return destination.push(endSegmentTable);
3003+ case HTML_TABLE_BODY_MODE:
3004+ return destination.push(endSegmentTableBody);
3005+ case HTML_TABLE_ROW_MODE:
3006+ return destination.push(endSegmentTableRow);
3007+ case HTML_COLGROUP_MODE:
3008+ return destination.push(endSegmentColGroup);
3009+ default:
3010+ throw Error("Unknown insertion mode. This is a bug in React.");
3011+ }
3012+ }
3013+ function escapeJSStringsForInstructionScripts(input) {
3014+ return JSON.stringify(input).replace(
3015+ regexForJSStringsInInstructionScripts,
3016+ function (match) {
3017+ switch (match) {
3018+ case "<":
3019+ return "\\u003c";
3020+ case "\u2028":
3021+ return "\\u2028";
3022+ case "\u2029":
3023+ return "\\u2029";
3024+ default:
3025+ throw Error(
3026+ "escapeJSStringsForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React"
3027+ );
3028+ }
60093029 }
6010−
6011− return;
3030+ );
3031+ }
3032+ function escapeJSObjectForInstructionScripts(input) {
3033+ return JSON.stringify(input).replace(
3034+ regexForJSStringsInScripts,
3035+ function (match) {
3036+ switch (match) {
3037+ case "&":
3038+ return "\\u0026";
3039+ case ">":
3040+ return "\\u003e";
3041+ case "<":
3042+ return "\\u003c";
3043+ case "\u2028":
3044+ return "\\u2028";
3045+ case "\u2029":
3046+ return "\\u2029";
3047+ default:
3048+ throw Error(
3049+ "escapeJSObjectForInstructionScripts encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React"
3050+ );
3051+ }
3052+ }
3053+ );
3054+ }
3055+ function flushStyleTagsLateForBoundary(styleQueue) {
3056+ var rules = styleQueue.rules,
3057+ hrefs = styleQueue.hrefs;
3058+ 0 < rules.length &&
3059+ 0 === hrefs.length &&
3060+ console.error(
3061+ "React expected to have at least one href for an a hoistable style but found none. This is a bug in React."
3062+ );
3063+ var i = 0;
3064+ if (hrefs.length) {
3065+ this.push(currentlyFlushingRenderState.startInlineStyle);
3066+ this.push(lateStyleTagResourceOpen1);
3067+ this.push(styleQueue.precedence);
3068+ for (this.push(lateStyleTagResourceOpen2); i < hrefs.length - 1; i++)
3069+ this.push(hrefs[i]), this.push(spaceSeparator);
3070+ this.push(hrefs[i]);
3071+ this.push(lateStyleTagResourceOpen3);
3072+ for (i = 0; i < rules.length; i++) this.push(rules[i]);
3073+ destinationHasCapacity = this.push(lateStyleTagTemplateClose);
3074+ currentlyRenderingBoundaryHasStylesToHoist = !0;
3075+ rules.length = 0;
3076+ hrefs.length = 0;
3077+ }
3078+ }
3079+ function hasStylesToHoist(stylesheet) {
3080+ return stylesheet.state !== PREAMBLE
3081+ ? (currentlyRenderingBoundaryHasStylesToHoist = !0)
3082+ : !1;
3083+ }
3084+ function writeHoistablesForBoundary(
3085+ destination,
3086+ hoistableState,
3087+ renderState
3088+ ) {
3089+ currentlyRenderingBoundaryHasStylesToHoist = !1;
3090+ destinationHasCapacity = !0;
3091+ currentlyFlushingRenderState = renderState;
3092+ hoistableState.styles.forEach(flushStyleTagsLateForBoundary, destination);
3093+ currentlyFlushingRenderState = null;
3094+ hoistableState.stylesheets.forEach(hasStylesToHoist);
3095+ currentlyRenderingBoundaryHasStylesToHoist &&
3096+ (renderState.stylesToHoist = !0);
3097+ return destinationHasCapacity;
3098+ }
3099+ function flushResource(resource) {
3100+ for (var i = 0; i < resource.length; i++) this.push(resource[i]);
3101+ resource.length = 0;
3102+ }
3103+ function flushStyleInPreamble(stylesheet) {
3104+ pushLinkImpl(stylesheetFlushingQueue, stylesheet.props);
3105+ for (var i = 0; i < stylesheetFlushingQueue.length; i++)
3106+ this.push(stylesheetFlushingQueue[i]);
3107+ stylesheetFlushingQueue.length = 0;
3108+ stylesheet.state = PREAMBLE;
3109+ }
3110+ function flushStylesInPreamble(styleQueue) {
3111+ var hasStylesheets = 0 < styleQueue.sheets.size;
3112+ styleQueue.sheets.forEach(flushStyleInPreamble, this);
3113+ styleQueue.sheets.clear();
3114+ var rules = styleQueue.rules,
3115+ hrefs = styleQueue.hrefs;
3116+ if (!hasStylesheets || hrefs.length) {
3117+ this.push(currentlyFlushingRenderState.startInlineStyle);
3118+ this.push(styleTagResourceOpen1);
3119+ this.push(styleQueue.precedence);
3120+ styleQueue = 0;
3121+ if (hrefs.length) {
3122+ for (
3123+ this.push(styleTagResourceOpen2);
3124+ styleQueue < hrefs.length - 1;
3125+ styleQueue++
3126+ )
3127+ this.push(hrefs[styleQueue]), this.push(spaceSeparator);
3128+ this.push(hrefs[styleQueue]);
3129+ }
3130+ this.push(styleTagResourceOpen3);
3131+ for (styleQueue = 0; styleQueue < rules.length; styleQueue++)
3132+ this.push(rules[styleQueue]);
3133+ this.push(styleTagResourceClose);
3134+ rules.length = 0;
3135+ hrefs.length = 0;
3136+ }
3137+ }
3138+ function preloadLateStyle(stylesheet) {
3139+ if (stylesheet.state === PENDING$1) {
3140+ stylesheet.state = PRELOADED;
3141+ var props = stylesheet.props;
3142+ pushLinkImpl(stylesheetFlushingQueue, {
3143+ rel: "preload",
3144+ as: "style",
3145+ href: stylesheet.props.href,
3146+ crossOrigin: props.crossOrigin,
3147+ fetchPriority: props.fetchPriority,
3148+ integrity: props.integrity,
3149+ media: props.media,
3150+ hrefLang: props.hrefLang,
3151+ referrerPolicy: props.referrerPolicy
3152+ });
3153+ for (
3154+ stylesheet = 0;
3155+ stylesheet < stylesheetFlushingQueue.length;
3156+ stylesheet++
3157+ )
3158+ this.push(stylesheetFlushingQueue[stylesheet]);
3159+ stylesheetFlushingQueue.length = 0;
3160+ }
3161+ }
3162+ function preloadLateStyles(styleQueue) {
3163+ styleQueue.sheets.forEach(preloadLateStyle, this);
3164+ styleQueue.sheets.clear();
3165+ }
3166+ function pushCompletedShellIdAttribute(target, resumableState) {
3167+ (resumableState.instructions & SentCompletedShellId) === NothingSent &&
3168+ ((resumableState.instructions |= SentCompletedShellId),
3169+ target.push(
3170+ completedShellIdAttributeStart,
3171+ escapeTextForBrowser("_" + resumableState.idPrefix + "R_"),
3172+ attributeEnd
3173+ ));
3174+ }
3175+ function writeStyleResourceDependenciesInJS(destination, hoistableState) {
3176+ destination.push(arrayFirstOpenBracket);
3177+ var nextArrayOpenBrackChunk = arrayFirstOpenBracket;
3178+ hoistableState.stylesheets.forEach(function (resource) {
3179+ if (resource.state !== PREAMBLE)
3180+ if (resource.state === LATE)
3181+ destination.push(nextArrayOpenBrackChunk),
3182+ (resource = resource.props.href),
3183+ checkAttributeStringCoercion(resource, "href"),
3184+ (resource = escapeJSObjectForInstructionScripts("" + resource)),
3185+ destination.push(resource),
3186+ destination.push(arrayCloseBracket),
3187+ (nextArrayOpenBrackChunk = arraySubsequentOpenBracket);
3188+ else {
3189+ destination.push(nextArrayOpenBrackChunk);
3190+ var precedence = resource.props["data-precedence"],
3191+ props = resource.props,
3192+ coercedHref = sanitizeURL("" + resource.props.href);
3193+ coercedHref = escapeJSObjectForInstructionScripts(coercedHref);
3194+ destination.push(coercedHref);
3195+ checkAttributeStringCoercion(precedence, "precedence");
3196+ precedence = "" + precedence;
3197+ destination.push(arrayInterstitial);
3198+ precedence = escapeJSObjectForInstructionScripts(precedence);
3199+ destination.push(precedence);
3200+ for (var propKey in props)
3201+ if (
3202+ hasOwnProperty.call(props, propKey) &&
3203+ ((precedence = props[propKey]), null != precedence)
3204+ )
3205+ switch (propKey) {
3206+ case "href":
3207+ case "rel":
3208+ case "precedence":
3209+ case "data-precedence":
3210+ break;
3211+ case "children":
3212+ case "dangerouslySetInnerHTML":
3213+ throw Error(
3214+ "link is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
3215+ );
3216+ default:
3217+ writeStyleResourceAttributeInJS(
3218+ destination,
3219+ propKey,
3220+ precedence
3221+ );
3222+ }
3223+ destination.push(arrayCloseBracket);
3224+ nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
3225+ resource.state = LATE;
3226+ }
3227+ });
3228+ destination.push(arrayCloseBracket);
3229+ }
3230+ function writeStyleResourceAttributeInJS(destination, name, value) {
3231+ var attributeName = name.toLowerCase();
3232+ switch (typeof value) {
3233+ case "function":
3234+ case "symbol":
3235+ return;
60123236 }
6013− }
6014−
6015− if (typeof type === 'object' && type !== null) {
6016− switch (type.$$typeof) {
6017− case REACT_FORWARD_REF_TYPE:
6018− {
6019− renderForwardRef(request, task, type, props, ref);
3237+ switch (name) {
3238+ case "innerHTML":
3239+ case "dangerouslySetInnerHTML":
3240+ case "suppressContentEditableWarning":
3241+ case "suppressHydrationWarning":
3242+ case "style":
3243+ case "ref":
60203244 return;
3245+ case "className":
3246+ attributeName = "class";
3247+ checkAttributeStringCoercion(value, attributeName);
3248+ name = "" + value;
3249+ break;
3250+ case "hidden":
3251+ if (!1 === value) return;
3252+ name = "";
3253+ break;
3254+ case "src":
3255+ case "href":
3256+ value = sanitizeURL(value);
3257+ checkAttributeStringCoercion(value, attributeName);
3258+ name = "" + value;
3259+ break;
3260+ default:
3261+ if (
3262+ (2 < name.length &&
3263+ ("o" === name[0] || "O" === name[0]) &&
3264+ ("n" === name[1] || "N" === name[1])) ||
3265+ !isAttributeNameSafe(name)
3266+ )
3267+ return;
3268+ checkAttributeStringCoercion(value, attributeName);
3269+ name = "" + value;
3270+ }
3271+ destination.push(arrayInterstitial);
3272+ attributeName = escapeJSObjectForInstructionScripts(attributeName);
3273+ destination.push(attributeName);
3274+ destination.push(arrayInterstitial);
3275+ attributeName = escapeJSObjectForInstructionScripts(name);
3276+ destination.push(attributeName);
3277+ }
3278+ function createHoistableState() {
3279+ return { styles: new Set(), stylesheets: new Set(), suspenseyImages: !1 };
3280+ }
3281+ function preloadBootstrapScriptOrModule(
3282+ resumableState,
3283+ renderState,
3284+ href,
3285+ props
3286+ ) {
3287+ (resumableState.scriptResources.hasOwnProperty(href) ||
3288+ resumableState.moduleScriptResources.hasOwnProperty(href)) &&
3289+ console.error(
3290+ 'Internal React Error: React expected bootstrap script or module with src "%s" to not have been preloaded already. please file an issue',
3291+ href
3292+ );
3293+ resumableState.scriptResources[href] = EXISTS;
3294+ resumableState.moduleScriptResources[href] = EXISTS;
3295+ resumableState = [];
3296+ pushLinkImpl(resumableState, props);
3297+ renderState.bootstrapScripts.add(resumableState);
3298+ }
3299+ function adoptPreloadCredentials(target, preloadState) {
3300+ null == target.crossOrigin && (target.crossOrigin = preloadState[0]);
3301+ null == target.integrity && (target.integrity = preloadState[1]);
3302+ }
3303+ function getPreloadAsHeader(href, as, params) {
3304+ href = escapeHrefForLinkHeaderURLContext(href);
3305+ as = escapeStringForLinkHeaderQuotedParamValueContext(as, "as");
3306+ as = "<" + href + '>; rel=preload; as="' + as + '"';
3307+ for (var paramName in params)
3308+ hasOwnProperty.call(params, paramName) &&
3309+ ((href = params[paramName]),
3310+ "string" === typeof href &&
3311+ (as +=
3312+ "; " +
3313+ paramName.toLowerCase() +
3314+ '="' +
3315+ escapeStringForLinkHeaderQuotedParamValueContext(
3316+ href,
3317+ paramName
3318+ ) +
3319+ '"'));
3320+ return as;
3321+ }
3322+ function escapeHrefForLinkHeaderURLContext(hrefInput) {
3323+ checkAttributeStringCoercion(hrefInput, "href");
3324+ return ("" + hrefInput).replace(
3325+ regexForHrefInLinkHeaderURLContext,
3326+ escapeHrefForLinkHeaderURLContextReplacer
3327+ );
3328+ }
3329+ function escapeHrefForLinkHeaderURLContextReplacer(match) {
3330+ switch (match) {
3331+ case "<":
3332+ return "%3C";
3333+ case ">":
3334+ return "%3E";
3335+ case "\n":
3336+ return "%0A";
3337+ case "\r":
3338+ return "%0D";
3339+ default:
3340+ throw Error(
3341+ "escapeLinkHrefForHeaderContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React"
3342+ );
3343+ }
3344+ }
3345+ function escapeStringForLinkHeaderQuotedParamValueContext(value, name) {
3346+ willCoercionThrow(value) &&
3347+ (console.error(
3348+ "The provided `%s` option is an unsupported type %s. This value must be coerced to a string before using it here.",
3349+ name,
3350+ typeName(value)
3351+ ),
3352+ testStringCoercion(value));
3353+ return ("" + value).replace(
3354+ regexForLinkHeaderQuotedParamValueContext,
3355+ escapeStringForLinkHeaderQuotedParamValueContextReplacer
3356+ );
3357+ }
3358+ function escapeStringForLinkHeaderQuotedParamValueContextReplacer(match) {
3359+ switch (match) {
3360+ case '"':
3361+ return "%22";
3362+ case "'":
3363+ return "%27";
3364+ case ";":
3365+ return "%3B";
3366+ case ",":
3367+ return "%2C";
3368+ case "\n":
3369+ return "%0A";
3370+ case "\r":
3371+ return "%0D";
3372+ default:
3373+ throw Error(
3374+ "escapeStringForLinkHeaderQuotedParamValueContextReplacer encountered a match it does not know how to replace. this means the match regex and the replacement characters are no longer in sync. This is a bug in React"
3375+ );
3376+ }
3377+ }
3378+ function hoistStyleQueueDependency(styleQueue) {
3379+ this.styles.add(styleQueue);
3380+ }
3381+ function hoistStylesheetDependency(stylesheet) {
3382+ this.stylesheets.add(stylesheet);
3383+ }
3384+ function hoistHoistables(parentState, childState) {
3385+ childState.styles.forEach(hoistStyleQueueDependency, parentState);
3386+ childState.stylesheets.forEach(hoistStylesheetDependency, parentState);
3387+ childState.suspenseyImages && (parentState.suspenseyImages = !0);
3388+ }
3389+ function createRenderState(resumableState, generateStaticMarkup) {
3390+ var idPrefix = resumableState.idPrefix,
3391+ bootstrapChunks = [],
3392+ bootstrapScriptContent = resumableState.bootstrapScriptContent,
3393+ bootstrapScripts = resumableState.bootstrapScripts,
3394+ bootstrapModules = resumableState.bootstrapModules;
3395+ void 0 !== bootstrapScriptContent &&
3396+ (bootstrapChunks.push("<script"),
3397+ pushCompletedShellIdAttribute(bootstrapChunks, resumableState),
3398+ bootstrapChunks.push(
3399+ endOfStartTag,
3400+ escapeEntireInlineScriptContent(bootstrapScriptContent),
3401+ endInlineScript
3402+ ));
3403+ idPrefix = {
3404+ placeholderPrefix: idPrefix + "P:",
3405+ segmentPrefix: idPrefix + "S:",
3406+ boundaryPrefix: idPrefix + "B:",
3407+ startInlineScript: "<script",
3408+ startInlineStyle: "<style",
3409+ preamble: { htmlChunks: null, headChunks: null, bodyChunks: null },
3410+ externalRuntimeScript: null,
3411+ bootstrapChunks: bootstrapChunks,
3412+ importMapChunks: [],
3413+ onHeaders: void 0,
3414+ headers: null,
3415+ resets: {
3416+ font: {},
3417+ dns: {},
3418+ connect: { default: {}, anonymous: {}, credentials: {} },
3419+ image: {},
3420+ style: {}
3421+ },
3422+ charsetChunks: [],
3423+ viewportChunks: [],
3424+ hoistableChunks: [],
3425+ preconnects: new Set(),
3426+ fontPreloads: new Set(),
3427+ highImagePreloads: new Set(),
3428+ styles: new Map(),
3429+ bootstrapScripts: new Set(),
3430+ scripts: new Set(),
3431+ bulkPreloads: new Set(),
3432+ preloads: {
3433+ images: new Map(),
3434+ stylesheets: new Map(),
3435+ scripts: new Map(),
3436+ moduleScripts: new Map()
3437+ },
3438+ nonce: { script: void 0, style: void 0 },
3439+ hoistableState: null,
3440+ stylesToHoist: !1
3441+ };
3442+ if (void 0 !== bootstrapScripts)
3443+ for (
3444+ bootstrapScriptContent = 0;
3445+ bootstrapScriptContent < bootstrapScripts.length;
3446+ bootstrapScriptContent++
3447+ ) {
3448+ var scriptConfig = bootstrapScripts[bootstrapScriptContent],
3449+ src,
3450+ crossOrigin = void 0,
3451+ integrity = void 0,
3452+ props = {
3453+ rel: "preload",
3454+ as: "script",
3455+ fetchPriority: "low",
3456+ nonce: void 0
3457+ };
3458+ "string" === typeof scriptConfig
3459+ ? (props.href = src = scriptConfig)
3460+ : ((props.href = src = scriptConfig.src),
3461+ (props.integrity = integrity =
3462+ "string" === typeof scriptConfig.integrity
3463+ ? scriptConfig.integrity
3464+ : void 0),
3465+ (props.crossOrigin = crossOrigin =
3466+ "string" === typeof scriptConfig ||
3467+ null == scriptConfig.crossOrigin
3468+ ? void 0
3469+ : "use-credentials" === scriptConfig.crossOrigin
3470+ ? "use-credentials"
3471+ : ""));
3472+ preloadBootstrapScriptOrModule(resumableState, idPrefix, src, props);
3473+ bootstrapChunks.push(
3474+ '<script src="',
3475+ escapeTextForBrowser(src),
3476+ attributeEnd
3477+ );
3478+ "string" === typeof integrity &&
3479+ bootstrapChunks.push(
3480+ ' integrity="',
3481+ escapeTextForBrowser(integrity),
3482+ attributeEnd
3483+ );
3484+ "string" === typeof crossOrigin &&
3485+ bootstrapChunks.push(
3486+ ' crossorigin="',
3487+ escapeTextForBrowser(crossOrigin),
3488+ attributeEnd
3489+ );
3490+ pushCompletedShellIdAttribute(bootstrapChunks, resumableState);
3491+ bootstrapChunks.push(' async="">\x3c/script>');
60213492 }
6022−
6023− case REACT_MEMO_TYPE:
6024− {
6025− renderMemo(request, task, type, props, ref);
6026− return;
3493+ if (void 0 !== bootstrapModules)
3494+ for (
3495+ bootstrapScripts = 0;
3496+ bootstrapScripts < bootstrapModules.length;
3497+ bootstrapScripts++
3498+ )
3499+ (bootstrapScriptContent = bootstrapModules[bootstrapScripts]),
3500+ (crossOrigin = src = void 0),
3501+ (integrity = {
3502+ rel: "modulepreload",
3503+ fetchPriority: "low",
3504+ nonce: void 0
3505+ }),
3506+ "string" === typeof bootstrapScriptContent
3507+ ? (integrity.href = scriptConfig = bootstrapScriptContent)
3508+ : ((integrity.href = scriptConfig = bootstrapScriptContent.src),
3509+ (integrity.integrity = crossOrigin =
3510+ "string" === typeof bootstrapScriptContent.integrity
3511+ ? bootstrapScriptContent.integrity
3512+ : void 0),
3513+ (integrity.crossOrigin = src =
3514+ "string" === typeof bootstrapScriptContent ||
3515+ null == bootstrapScriptContent.crossOrigin
3516+ ? void 0
3517+ : "use-credentials" === bootstrapScriptContent.crossOrigin
3518+ ? "use-credentials"
3519+ : "")),
3520+ preloadBootstrapScriptOrModule(
3521+ resumableState,
3522+ idPrefix,
3523+ scriptConfig,
3524+ integrity
3525+ ),
3526+ bootstrapChunks.push(
3527+ '<script type="module" src="',
3528+ escapeTextForBrowser(scriptConfig),
3529+ attributeEnd
3530+ ),
3531+ "string" === typeof crossOrigin &&
3532+ bootstrapChunks.push(
3533+ ' integrity="',
3534+ escapeTextForBrowser(crossOrigin),
3535+ attributeEnd
3536+ ),
3537+ "string" === typeof src &&
3538+ bootstrapChunks.push(
3539+ ' crossorigin="',
3540+ escapeTextForBrowser(src),
3541+ attributeEnd
3542+ ),
3543+ pushCompletedShellIdAttribute(bootstrapChunks, resumableState),
3544+ bootstrapChunks.push(' async="">\x3c/script>');
3545+ return {
3546+ placeholderPrefix: idPrefix.placeholderPrefix,
3547+ segmentPrefix: idPrefix.segmentPrefix,
3548+ boundaryPrefix: idPrefix.boundaryPrefix,
3549+ startInlineScript: idPrefix.startInlineScript,
3550+ startInlineStyle: idPrefix.startInlineStyle,
3551+ preamble: idPrefix.preamble,
3552+ externalRuntimeScript: idPrefix.externalRuntimeScript,
3553+ bootstrapChunks: idPrefix.bootstrapChunks,
3554+ importMapChunks: idPrefix.importMapChunks,
3555+ onHeaders: idPrefix.onHeaders,
3556+ headers: idPrefix.headers,
3557+ resets: idPrefix.resets,
3558+ charsetChunks: idPrefix.charsetChunks,
3559+ viewportChunks: idPrefix.viewportChunks,
3560+ hoistableChunks: idPrefix.hoistableChunks,
3561+ preconnects: idPrefix.preconnects,
3562+ fontPreloads: idPrefix.fontPreloads,
3563+ highImagePreloads: idPrefix.highImagePreloads,
3564+ styles: idPrefix.styles,
3565+ bootstrapScripts: idPrefix.bootstrapScripts,
3566+ scripts: idPrefix.scripts,
3567+ bulkPreloads: idPrefix.bulkPreloads,
3568+ preloads: idPrefix.preloads,
3569+ nonce: idPrefix.nonce,
3570+ stylesToHoist: idPrefix.stylesToHoist,
3571+ generateStaticMarkup: generateStaticMarkup
3572+ };
3573+ }
3574+ function pushTextInstance(target, text, renderState, textEmbedded) {
3575+ if (renderState.generateStaticMarkup)
3576+ return target.push(escapeTextForBrowser(text)), !1;
3577+ "" === text
3578+ ? (target = textEmbedded)
3579+ : (textEmbedded && target.push("\x3c!-- --\x3e"),
3580+ target.push(escapeTextForBrowser(text)),
3581+ (target = !0));
3582+ return target;
3583+ }
3584+ function pushSegmentFinale(
3585+ target,
3586+ renderState,
3587+ lastPushedText,
3588+ textEmbedded
3589+ ) {
3590+ renderState.generateStaticMarkup ||
3591+ (lastPushedText && textEmbedded && target.push("\x3c!-- --\x3e"));
3592+ }
3593+ function getComponentNameFromType(type) {
3594+ if (null == type) return null;
3595+ if ("function" === typeof type)
3596+ return type.$$typeof === REACT_CLIENT_REFERENCE
3597+ ? null
3598+ : type.displayName || type.name || null;
3599+ if ("string" === typeof type) return type;
3600+ switch (type) {
3601+ case REACT_FRAGMENT_TYPE:
3602+ return "Fragment";
3603+ case REACT_PROFILER_TYPE:
3604+ return "Profiler";
3605+ case REACT_STRICT_MODE_TYPE:
3606+ return "StrictMode";
3607+ case REACT_SUSPENSE_TYPE:
3608+ return "Suspense";
3609+ case REACT_SUSPENSE_LIST_TYPE:
3610+ return "SuspenseList";
3611+ case REACT_ACTIVITY_TYPE:
3612+ return "Activity";
3613+ }
3614+ if ("object" === typeof type)
3615+ switch (
3616+ ("number" === typeof type.tag &&
3617+ console.error(
3618+ "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
3619+ ),
3620+ type.$$typeof)
3621+ ) {
3622+ case REACT_PORTAL_TYPE:
3623+ return "Portal";
3624+ case REACT_CONTEXT_TYPE:
3625+ return type.displayName || "Context";
3626+ case REACT_CONSUMER_TYPE:
3627+ return (type._context.displayName || "Context") + ".Consumer";
3628+ case REACT_FORWARD_REF_TYPE:
3629+ var innerType = type.render;
3630+ type = type.displayName;
3631+ type ||
3632+ ((type = innerType.displayName || innerType.name || ""),
3633+ (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
3634+ return type;
3635+ case REACT_MEMO_TYPE:
3636+ return (
3637+ (innerType = type.displayName || null),
3638+ null !== innerType
3639+ ? innerType
3640+ : getComponentNameFromType(type.type) || "Memo"
3641+ );
3642+ case REACT_LAZY_TYPE:
3643+ innerType = type._payload;
3644+ type = type._init;
3645+ try {
3646+ return getComponentNameFromType(type(innerType));
3647+ } catch (x) {}
60273648 }
6028−
6029− case REACT_PROVIDER_TYPE:
6030− {
6031− renderContextProvider(request, task, type, props);
6032− return;
3649+ return null;
3650+ }
3651+ function popToNearestCommonAncestor(prev, next) {
3652+ if (prev !== next) {
3653+ prev.context._currentValue2 = prev.parentValue;
3654+ prev = prev.parent;
3655+ var parentNext = next.parent;
3656+ if (null === prev) {
3657+ if (null !== parentNext)
3658+ throw Error(
3659+ "The stacks must reach the root at the same time. This is a bug in React."
3660+ );
3661+ } else {
3662+ if (null === parentNext)
3663+ throw Error(
3664+ "The stacks must reach the root at the same time. This is a bug in React."
3665+ );
3666+ popToNearestCommonAncestor(prev, parentNext);
60333667 }
6034−
6035− case REACT_CONTEXT_TYPE:
6036− {
6037− renderContextConsumer(request, task, type, props);
6038− return;
3668+ next.context._currentValue2 = next.value;
3669+ }
3670+ }
3671+ function popAllPrevious(prev) {
3672+ prev.context._currentValue2 = prev.parentValue;
3673+ prev = prev.parent;
3674+ null !== prev && popAllPrevious(prev);
3675+ }
3676+ function pushAllNext(next) {
3677+ var parentNext = next.parent;
3678+ null !== parentNext && pushAllNext(parentNext);
3679+ next.context._currentValue2 = next.value;
3680+ }
3681+ function popPreviousToCommonLevel(prev, next) {
3682+ prev.context._currentValue2 = prev.parentValue;
3683+ prev = prev.parent;
3684+ if (null === prev)
3685+ throw Error(
3686+ "The depth must equal at least at zero before reaching the root. This is a bug in React."
3687+ );
3688+ prev.depth === next.depth
3689+ ? popToNearestCommonAncestor(prev, next)
3690+ : popPreviousToCommonLevel(prev, next);
3691+ }
3692+ function popNextToCommonLevel(prev, next) {
3693+ var parentNext = next.parent;
3694+ if (null === parentNext)
3695+ throw Error(
3696+ "The depth must equal at least at zero before reaching the root. This is a bug in React."
3697+ );
3698+ prev.depth === parentNext.depth
3699+ ? popToNearestCommonAncestor(prev, parentNext)
3700+ : popNextToCommonLevel(prev, parentNext);
3701+ next.context._currentValue2 = next.value;
3702+ }
3703+ function switchContext(newSnapshot) {
3704+ var prev = currentActiveSnapshot;
3705+ prev !== newSnapshot &&
3706+ (null === prev
3707+ ? pushAllNext(newSnapshot)
3708+ : null === newSnapshot
3709+ ? popAllPrevious(prev)
3710+ : prev.depth === newSnapshot.depth
3711+ ? popToNearestCommonAncestor(prev, newSnapshot)
3712+ : prev.depth > newSnapshot.depth
3713+ ? popPreviousToCommonLevel(prev, newSnapshot)
3714+ : popNextToCommonLevel(prev, newSnapshot),
3715+ (currentActiveSnapshot = newSnapshot));
3716+ }
3717+ function warnOnInvalidCallback(callback) {
3718+ if (null !== callback && "function" !== typeof callback) {
3719+ var key = String(callback);
3720+ didWarnOnInvalidCallback.has(key) ||
3721+ (didWarnOnInvalidCallback.add(key),
3722+ console.error(
3723+ "Expected the last optional `callback` argument to be a function. Instead received: %s.",
3724+ callback
3725+ ));
3726+ }
3727+ }
3728+ function warnNoop(publicInstance, callerName) {
3729+ publicInstance =
3730+ ((publicInstance = publicInstance.constructor) &&
3731+ getComponentNameFromType(publicInstance)) ||
3732+ "ReactClass";
3733+ var warningKey = publicInstance + "." + callerName;
3734+ didWarnAboutNoopUpdateForComponent[warningKey] ||
3735+ (console.error(
3736+ "Can only update a mounting component. This usually means you called %s() outside componentWillMount() on the server. This is a no-op.\n\nPlease check the code for the %s component.",
3737+ callerName,
3738+ publicInstance
3739+ ),
3740+ (didWarnAboutNoopUpdateForComponent[warningKey] = !0));
3741+ }
3742+ function pushTreeContext(baseContext, totalChildren, index) {
3743+ var baseIdWithLeadingBit = baseContext.id;
3744+ baseContext = baseContext.overflow;
3745+ var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
3746+ baseIdWithLeadingBit &= ~(1 << baseLength);
3747+ index += 1;
3748+ var length = 32 - clz32(totalChildren) + baseLength;
3749+ if (30 < length) {
3750+ var numberOfOverflowBits = baseLength - (baseLength % 5);
3751+ length = (
3752+ baseIdWithLeadingBit &
3753+ ((1 << numberOfOverflowBits) - 1)
3754+ ).toString(32);
3755+ baseIdWithLeadingBit >>= numberOfOverflowBits;
3756+ baseLength -= numberOfOverflowBits;
3757+ return {
3758+ id:
3759+ (1 << (32 - clz32(totalChildren) + baseLength)) |
3760+ (index << baseLength) |
3761+ baseIdWithLeadingBit,
3762+ overflow: length + baseContext
3763+ };
3764+ }
3765+ return {
3766+ id: (1 << length) | (index << baseLength) | baseIdWithLeadingBit,
3767+ overflow: baseContext
3768+ };
3769+ }
3770+ function clz32Fallback(x) {
3771+ x >>>= 0;
3772+ return 0 === x ? 32 : (31 - ((log(x) / LN2) | 0)) | 0;
3773+ }
3774+ function noop() {}
3775+ function trackUsedThenable(thenableState, thenable, index) {
3776+ index = thenableState[index];
3777+ void 0 === index
3778+ ? thenableState.push(thenable)
3779+ : index !== thenable && (thenable.then(noop, noop), (thenable = index));
3780+ switch (thenable.status) {
3781+ case "fulfilled":
3782+ return thenable.value;
3783+ case "rejected":
3784+ throw thenable.reason;
3785+ default:
3786+ "string" === typeof thenable.status
3787+ ? thenable.then(noop, noop)
3788+ : ((thenableState = thenable),
3789+ (thenableState.status = "pending"),
3790+ thenableState.then(
3791+ function (fulfilledValue) {
3792+ if ("pending" === thenable.status) {
3793+ var fulfilledThenable = thenable;
3794+ fulfilledThenable.status = "fulfilled";
3795+ fulfilledThenable.value = fulfilledValue;
3796+ }
3797+ },
3798+ function (error) {
3799+ if ("pending" === thenable.status) {
3800+ var rejectedThenable = thenable;
3801+ rejectedThenable.status = "rejected";
3802+ rejectedThenable.reason = error;
3803+ }
3804+ }
3805+ ));
3806+ switch (thenable.status) {
3807+ case "fulfilled":
3808+ return thenable.value;
3809+ case "rejected":
3810+ throw thenable.reason;
3811+ }
3812+ suspendedThenable = thenable;
3813+ throw SuspenseException;
3814+ }
3815+ }
3816+ function getSuspendedThenable() {
3817+ if (null === suspendedThenable)
3818+ throw Error(
3819+ "Expected a suspended thenable. This is a bug in React. Please file an issue."
3820+ );
3821+ var thenable = suspendedThenable;
3822+ suspendedThenable = null;
3823+ return thenable;
3824+ }
3825+ function is(x, y) {
3826+ return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
3827+ }
3828+ function resolveCurrentlyRenderingComponent() {
3829+ if (null === currentlyRenderingComponent)
3830+ throw Error(
3831+ "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
3832+ );
3833+ isInHookUserCodeInDev &&
3834+ console.error(
3835+ "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. You can only call Hooks at the top level of your React function. For more information, see https://react.dev/link/rules-of-hooks"
3836+ );
3837+ return currentlyRenderingComponent;
3838+ }
3839+ function createHook() {
3840+ if (0 < numberOfReRenders)
3841+ throw Error("Rendered more hooks than during the previous render");
3842+ return { memoizedState: null, queue: null, next: null };
3843+ }
3844+ function createWorkInProgressHook() {
3845+ null === workInProgressHook
3846+ ? null === firstWorkInProgressHook
3847+ ? ((isReRender = !1),
3848+ (firstWorkInProgressHook = workInProgressHook = createHook()))
3849+ : ((isReRender = !0), (workInProgressHook = firstWorkInProgressHook))
3850+ : null === workInProgressHook.next
3851+ ? ((isReRender = !1),
3852+ (workInProgressHook = workInProgressHook.next = createHook()))
3853+ : ((isReRender = !0), (workInProgressHook = workInProgressHook.next));
3854+ return workInProgressHook;
3855+ }
3856+ function getThenableStateAfterSuspending() {
3857+ var state = thenableState;
3858+ thenableState = null;
3859+ return state;
3860+ }
3861+ function resetHooksState() {
3862+ isInHookUserCodeInDev = !1;
3863+ currentlyRenderingKeyPath =
3864+ currentlyRenderingRequest =
3865+ currentlyRenderingTask =
3866+ currentlyRenderingComponent =
3867+ null;
3868+ didScheduleRenderPhaseUpdate = !1;
3869+ firstWorkInProgressHook = null;
3870+ numberOfReRenders = 0;
3871+ workInProgressHook = renderPhaseUpdates = null;
3872+ }
3873+ function readContext(context) {
3874+ isInHookUserCodeInDev &&
3875+ console.error(
3876+ "Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."
3877+ );
3878+ return context._currentValue2;
3879+ }
3880+ function basicStateReducer(state, action) {
3881+ return "function" === typeof action ? action(state) : action;
3882+ }
3883+ function useReducer(reducer, initialArg, init) {
3884+ reducer !== basicStateReducer && (currentHookNameInDev = "useReducer");
3885+ currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
3886+ workInProgressHook = createWorkInProgressHook();
3887+ if (isReRender) {
3888+ init = workInProgressHook.queue;
3889+ initialArg = init.dispatch;
3890+ if (null !== renderPhaseUpdates) {
3891+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(init);
3892+ if (void 0 !== firstRenderPhaseUpdate) {
3893+ renderPhaseUpdates.delete(init);
3894+ init = workInProgressHook.memoizedState;
3895+ do {
3896+ var action = firstRenderPhaseUpdate.action;
3897+ isInHookUserCodeInDev = !0;
3898+ init = reducer(init, action);
3899+ isInHookUserCodeInDev = !1;
3900+ firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
3901+ } while (null !== firstRenderPhaseUpdate);
3902+ workInProgressHook.memoizedState = init;
3903+ return [init, initialArg];
3904+ }
60393905 }
6040−
6041− case REACT_LAZY_TYPE:
6042− {
6043− renderLazyComponent(request, task, type, props);
6044− return;
3906+ return [workInProgressHook.memoizedState, initialArg];
3907+ }
3908+ isInHookUserCodeInDev = !0;
3909+ reducer =
3910+ reducer === basicStateReducer
3911+ ? "function" === typeof initialArg
3912+ ? initialArg()
3913+ : initialArg
3914+ : void 0 !== init
3915+ ? init(initialArg)
3916+ : initialArg;
3917+ isInHookUserCodeInDev = !1;
3918+ workInProgressHook.memoizedState = reducer;
3919+ reducer = workInProgressHook.queue = { last: null, dispatch: null };
3920+ reducer = reducer.dispatch = dispatchAction.bind(
3921+ null,
3922+ currentlyRenderingComponent,
3923+ reducer
3924+ );
3925+ return [workInProgressHook.memoizedState, reducer];
3926+ }
3927+ function useMemo(nextCreate, deps) {
3928+ currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
3929+ workInProgressHook = createWorkInProgressHook();
3930+ deps = void 0 === deps ? null : deps;
3931+ if (null !== workInProgressHook) {
3932+ var prevState = workInProgressHook.memoizedState;
3933+ if (null !== prevState && null !== deps) {
3934+ a: {
3935+ var JSCompiler_inline_result = prevState[1];
3936+ if (null === JSCompiler_inline_result)
3937+ console.error(
3938+ "%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.",
3939+ currentHookNameInDev
3940+ ),
3941+ (JSCompiler_inline_result = !1);
3942+ else {
3943+ deps.length !== JSCompiler_inline_result.length &&
3944+ console.error(
3945+ "The final argument passed to %s changed size between renders. The order and size of this array must remain constant.\n\nPrevious: %s\nIncoming: %s",
3946+ currentHookNameInDev,
3947+ "[" + deps.join(", ") + "]",
3948+ "[" + JSCompiler_inline_result.join(", ") + "]"
3949+ );
3950+ for (
3951+ var i = 0;
3952+ i < JSCompiler_inline_result.length && i < deps.length;
3953+ i++
3954+ )
3955+ if (!objectIs(deps[i], JSCompiler_inline_result[i])) {
3956+ JSCompiler_inline_result = !1;
3957+ break a;
3958+ }
3959+ JSCompiler_inline_result = !0;
3960+ }
3961+ }
3962+ if (JSCompiler_inline_result) return prevState[0];
60453963 }
6046− }
6047− }
6048−
6049− var info = '';
6050−
6051− {
6052− if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
6053− info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and " + 'named imports.';
6054− }
6055− }
6056−
6057− throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
6058−}
6059−
6060−function validateIterable(iterable, iteratorFn) {
6061− {
6062− // We don't support rendering Generators because it's a mutation.
6063− // See https://github.com/facebook/react/issues/12995
6064− if (typeof Symbol === 'function' && // $FlowFixMe Flow doesn't know about toStringTag
6065− iterable[Symbol.toStringTag] === 'Generator') {
6066− if (!didWarnAboutGenerators) {
6067− error('Using Generators as children is unsupported and will likely yield ' + 'unexpected results because enumerating a generator mutates it. ' + 'You may convert it to an array with `Array.from()` or the ' + '`[...spread]` operator before rendering. Keep in mind ' + 'you might need to polyfill these features for older browsers.');
6068− }
6069−
6070− didWarnAboutGenerators = true;
6071− } // Warn about using Maps as children
6072−
6073−
6074− if (iterable.entries === iteratorFn) {
6075− if (!didWarnAboutMaps) {
6076− error('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.');
60773964 }
6078−
6079− didWarnAboutMaps = true;
6080− }
6081− }
6082−}
6083−
6084−function renderNodeDestructive(request, task, node) {
6085− {
6086− // In Dev we wrap renderNodeDestructiveImpl in a try / catch so we can capture
6087− // a component stack at the right place in the tree. We don't do this in renderNode
6088− // becuase it is not called at every layer of the tree and we may lose frames
6089− try {
6090− return renderNodeDestructiveImpl(request, task, node);
6091− } catch (x) {
6092− if (typeof x === 'object' && x !== null && typeof x.then === 'function') ; else {
6093− // This is an error, stash the component stack if it is null.
6094− lastBoundaryErrorComponentStackDev = lastBoundaryErrorComponentStackDev !== null ? lastBoundaryErrorComponentStackDev : getCurrentStackInDEV();
6095− } // rethrow so normal suspense logic can handle thrown value accordingly
6096−
6097−
6098− throw x;
3965+ isInHookUserCodeInDev = !0;
3966+ nextCreate = nextCreate();
3967+ isInHookUserCodeInDev = !1;
3968+ workInProgressHook.memoizedState = [nextCreate, deps];
3969+ return nextCreate;
3970+ }
3971+ function dispatchAction(componentIdentity, queue, action) {
3972+ if (25 <= numberOfReRenders)
3973+ throw Error(
3974+ "Too many re-renders. React limits the number of renders to prevent an infinite loop."
3975+ );
3976+ if (componentIdentity === currentlyRenderingComponent)
3977+ if (
3978+ ((didScheduleRenderPhaseUpdate = !0),
3979+ (componentIdentity = { action: action, next: null }),
3980+ null === renderPhaseUpdates && (renderPhaseUpdates = new Map()),
3981+ (action = renderPhaseUpdates.get(queue)),
3982+ void 0 === action)
3983+ )
3984+ renderPhaseUpdates.set(queue, componentIdentity);
3985+ else {
3986+ for (queue = action; null !== queue.next; ) queue = queue.next;
3987+ queue.next = componentIdentity;
3988+ }
60993989 }
6100− }
6101−} // This function by it self renders a node and consumes the task by mutating it
6102−// to update the current execution state.
6103−
6104−
6105−function renderNodeDestructiveImpl(request, task, node) {
6106− // Stash the node we're working on. We'll pick up from this task in case
6107− // something suspends.
6108− task.node = node; // Handle object types
6109−
6110− if (typeof node === 'object' && node !== null) {
6111− switch (node.$$typeof) {
6112− case REACT_ELEMENT_TYPE:
6113− {
6114− var element = node;
6115− var type = element.type;
6116− var props = element.props;
6117− var ref = element.ref;
6118− renderElement(request, task, type, props, ref);
6119− return;
3990+ function throwOnUseEffectEventCall() {
3991+ throw Error(
3992+ "A function wrapped in useEffectEvent can't be called during rendering."
3993+ );
3994+ }
3995+ function unsupportedStartTransition() {
3996+ throw Error("startTransition cannot be called during server rendering.");
3997+ }
3998+ function unsupportedSetOptimisticState() {
3999+ throw Error("Cannot update optimistic state while rendering.");
4000+ }
4001+ function useActionState(action, initialState, permalink) {
4002+ resolveCurrentlyRenderingComponent();
4003+ var actionStateHookIndex = actionStateCounter++,
4004+ request = currentlyRenderingRequest;
4005+ if ("function" === typeof action.$$FORM_ACTION) {
4006+ var nextPostbackStateKey = null,
4007+ componentKeyPath = currentlyRenderingKeyPath;
4008+ request = request.formState;
4009+ var isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
4010+ if (null !== request && "function" === typeof isSignatureEqual) {
4011+ var postbackKey = request[1];
4012+ isSignatureEqual.call(action, request[2], request[3]) &&
4013+ ((nextPostbackStateKey =
4014+ void 0 !== permalink
4015+ ? "p" + permalink
4016+ : "k" +
4017+ murmurhash3_32_gc(
4018+ JSON.stringify([
4019+ componentKeyPath,
4020+ null,
4021+ actionStateHookIndex
4022+ ]),
4023+ 0
4024+ )),
4025+ postbackKey === nextPostbackStateKey &&
4026+ ((actionStateMatchingIndex = actionStateHookIndex),
4027+ (initialState = request[0])));
61204028 }
6121−
6122− case REACT_PORTAL_TYPE:
6123− throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
6124− // eslint-disable-next-line-no-fallthrough
6125−
6126− case REACT_LAZY_TYPE:
6127− {
6128− var lazyNode = node;
6129− var payload = lazyNode._payload;
6130− var init = lazyNode._init;
6131− var resolvedNode;
6132−
6133− {
4029+ var boundAction = action.bind(null, initialState);
4030+ action = function (payload) {
4031+ boundAction(payload);
4032+ };
4033+ "function" === typeof boundAction.$$FORM_ACTION &&
4034+ (action.$$FORM_ACTION = function (prefix) {
4035+ prefix = boundAction.$$FORM_ACTION(prefix);
4036+ void 0 !== permalink &&
4037+ (checkAttributeStringCoercion(permalink, "target"),
4038+ (permalink += ""),
4039+ (prefix.action = permalink));
4040+ var formData = prefix.data;
4041+ formData &&
4042+ (null === nextPostbackStateKey &&
4043+ (nextPostbackStateKey =
4044+ void 0 !== permalink
4045+ ? "p" + permalink
4046+ : "k" +
4047+ murmurhash3_32_gc(
4048+ JSON.stringify([
4049+ componentKeyPath,
4050+ null,
4051+ actionStateHookIndex
4052+ ]),
4053+ 0
4054+ )),
4055+ formData.append("$ACTION_KEY", nextPostbackStateKey));
4056+ return prefix;
4057+ });
4058+ return [initialState, action, !1];
4059+ }
4060+ var _boundAction = action.bind(null, initialState);
4061+ return [
4062+ initialState,
4063+ function (payload) {
4064+ _boundAction(payload);
4065+ },
4066+ !1
4067+ ];
4068+ }
4069+ function unwrapThenable(thenable) {
4070+ var index = thenableIndexCounter;
4071+ thenableIndexCounter += 1;
4072+ null === thenableState && (thenableState = []);
4073+ return trackUsedThenable(thenableState, thenable, index);
4074+ }
4075+ function unsupportedRefresh() {
4076+ throw Error("Cache cannot be refreshed during server rendering.");
4077+ }
4078+ function disabledLog() {}
4079+ function disableLogs() {
4080+ if (0 === disabledDepth) {
4081+ prevLog = console.log;
4082+ prevInfo = console.info;
4083+ prevWarn = console.warn;
4084+ prevError = console.error;
4085+ prevGroup = console.group;
4086+ prevGroupCollapsed = console.groupCollapsed;
4087+ prevGroupEnd = console.groupEnd;
4088+ var props = {
4089+ configurable: !0,
4090+ enumerable: !0,
4091+ value: disabledLog,
4092+ writable: !0
4093+ };
4094+ Object.defineProperties(console, {
4095+ info: props,
4096+ log: props,
4097+ warn: props,
4098+ error: props,
4099+ group: props,
4100+ groupCollapsed: props,
4101+ groupEnd: props
4102+ });
4103+ }
4104+ disabledDepth++;
4105+ }
4106+ function reenableLogs() {
4107+ disabledDepth--;
4108+ if (0 === disabledDepth) {
4109+ var props = { configurable: !0, enumerable: !0, writable: !0 };
4110+ Object.defineProperties(console, {
4111+ log: assign({}, props, { value: prevLog }),
4112+ info: assign({}, props, { value: prevInfo }),
4113+ warn: assign({}, props, { value: prevWarn }),
4114+ error: assign({}, props, { value: prevError }),
4115+ group: assign({}, props, { value: prevGroup }),
4116+ groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
4117+ groupEnd: assign({}, props, { value: prevGroupEnd })
4118+ });
4119+ }
4120+ 0 > disabledDepth &&
4121+ console.error(
4122+ "disabledDepth fell below zero. This is a bug in React. Please file an issue."
4123+ );
4124+ }
4125+ function formatOwnerStack(error) {
4126+ var prevPrepareStackTrace = Error.prepareStackTrace;
4127+ Error.prepareStackTrace = void 0;
4128+ error = error.stack;
4129+ Error.prepareStackTrace = prevPrepareStackTrace;
4130+ error.startsWith("Error: react-stack-top-frame\n") &&
4131+ (error = error.slice(29));
4132+ prevPrepareStackTrace = error.indexOf("\n");
4133+ -1 !== prevPrepareStackTrace &&
4134+ (error = error.slice(prevPrepareStackTrace + 1));
4135+ prevPrepareStackTrace = error.indexOf("react_stack_bottom_frame");
4136+ -1 !== prevPrepareStackTrace &&
4137+ (prevPrepareStackTrace = error.lastIndexOf(
4138+ "\n",
4139+ prevPrepareStackTrace
4140+ ));
4141+ if (-1 !== prevPrepareStackTrace)
4142+ error = error.slice(0, prevPrepareStackTrace);
4143+ else return "";
4144+ return error;
4145+ }
4146+ function describeBuiltInComponentFrame(name) {
4147+ if (void 0 === prefix)
4148+ try {
4149+ throw Error();
4150+ } catch (x) {
4151+ var match = x.stack.trim().match(/\n( *(at )?)/);
4152+ prefix = (match && match[1]) || "";
4153+ suffix =
4154+ -1 < x.stack.indexOf("\n at")
4155+ ? " (<anonymous>)"
4156+ : -1 < x.stack.indexOf("@")
4157+ ? "@unknown:0:0"
4158+ : "";
4159+ }
4160+ return "\n" + prefix + name + suffix;
4161+ }
4162+ function describeNativeComponentFrame(fn, construct) {
4163+ if (!fn || reentry) return "";
4164+ var frame = componentFrameCache.get(fn);
4165+ if (void 0 !== frame) return frame;
4166+ reentry = !0;
4167+ frame = Error.prepareStackTrace;
4168+ Error.prepareStackTrace = void 0;
4169+ var previousDispatcher = null;
4170+ previousDispatcher = ReactSharedInternals.H;
4171+ ReactSharedInternals.H = null;
4172+ disableLogs();
4173+ try {
4174+ var RunInRootFrame = {
4175+ DetermineComponentFrameRoot: function () {
4176+ try {
4177+ if (construct) {
4178+ var Fake = function () {
4179+ throw Error();
4180+ };
4181+ Object.defineProperty(Fake.prototype, "props", {
4182+ set: function () {
4183+ throw Error();
4184+ }
4185+ });
4186+ if ("object" === typeof Reflect && Reflect.construct) {
4187+ try {
4188+ Reflect.construct(Fake, []);
4189+ } catch (x) {
4190+ var control = x;
4191+ }
4192+ Reflect.construct(fn, [], Fake);
4193+ } else {
4194+ try {
4195+ Fake.call();
4196+ } catch (x$0) {
4197+ control = x$0;
4198+ }
4199+ fn.call(Fake.prototype);
4200+ }
4201+ } else {
4202+ try {
4203+ throw Error();
4204+ } catch (x$1) {
4205+ control = x$1;
4206+ }
4207+ (Fake = fn()) &&
4208+ "function" === typeof Fake.catch &&
4209+ Fake.catch(function () {});
4210+ }
4211+ } catch (sample) {
4212+ if (sample && control && "string" === typeof sample.stack)
4213+ return [sample.stack, control.stack];
4214+ }
4215+ return [null, null];
4216+ }
4217+ };
4218+ RunInRootFrame.DetermineComponentFrameRoot.displayName =
4219+ "DetermineComponentFrameRoot";
4220+ var namePropDescriptor = Object.getOwnPropertyDescriptor(
4221+ RunInRootFrame.DetermineComponentFrameRoot,
4222+ "name"
4223+ );
4224+ namePropDescriptor &&
4225+ namePropDescriptor.configurable &&
4226+ Object.defineProperty(
4227+ RunInRootFrame.DetermineComponentFrameRoot,
4228+ "name",
4229+ { value: "DetermineComponentFrameRoot" }
4230+ );
4231+ var _RunInRootFrame$Deter =
4232+ RunInRootFrame.DetermineComponentFrameRoot(),
4233+ sampleStack = _RunInRootFrame$Deter[0],
4234+ controlStack = _RunInRootFrame$Deter[1];
4235+ if (sampleStack && controlStack) {
4236+ var sampleLines = sampleStack.split("\n"),
4237+ controlLines = controlStack.split("\n");
4238+ for (
4239+ _RunInRootFrame$Deter = namePropDescriptor = 0;
4240+ namePropDescriptor < sampleLines.length &&
4241+ !sampleLines[namePropDescriptor].includes(
4242+ "DetermineComponentFrameRoot"
4243+ );
4244+
4245+ )
4246+ namePropDescriptor++;
4247+ for (
4248+ ;
4249+ _RunInRootFrame$Deter < controlLines.length &&
4250+ !controlLines[_RunInRootFrame$Deter].includes(
4251+ "DetermineComponentFrameRoot"
4252+ );
4253+
4254+ )
4255+ _RunInRootFrame$Deter++;
4256+ if (
4257+ namePropDescriptor === sampleLines.length ||
4258+ _RunInRootFrame$Deter === controlLines.length
4259+ )
4260+ for (
4261+ namePropDescriptor = sampleLines.length - 1,
4262+ _RunInRootFrame$Deter = controlLines.length - 1;
4263+ 1 <= namePropDescriptor &&
4264+ 0 <= _RunInRootFrame$Deter &&
4265+ sampleLines[namePropDescriptor] !==
4266+ controlLines[_RunInRootFrame$Deter];
4267+
4268+ )
4269+ _RunInRootFrame$Deter--;
4270+ for (
4271+ ;
4272+ 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter;
4273+ namePropDescriptor--, _RunInRootFrame$Deter--
4274+ )
4275+ if (
4276+ sampleLines[namePropDescriptor] !==
4277+ controlLines[_RunInRootFrame$Deter]
4278+ ) {
4279+ if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
4280+ do
4281+ if (
4282+ (namePropDescriptor--,
4283+ _RunInRootFrame$Deter--,
4284+ 0 > _RunInRootFrame$Deter ||
4285+ sampleLines[namePropDescriptor] !==
4286+ controlLines[_RunInRootFrame$Deter])
4287+ ) {
4288+ var _frame =
4289+ "\n" +
4290+ sampleLines[namePropDescriptor].replace(
4291+ " at new ",
4292+ " at "
4293+ );
4294+ fn.displayName &&
4295+ _frame.includes("<anonymous>") &&
4296+ (_frame = _frame.replace("<anonymous>", fn.displayName));
4297+ "function" === typeof fn &&
4298+ componentFrameCache.set(fn, _frame);
4299+ return _frame;
4300+ }
4301+ while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
4302+ }
4303+ break;
4304+ }
4305+ }
4306+ } finally {
4307+ (reentry = !1),
4308+ (ReactSharedInternals.H = previousDispatcher),
4309+ reenableLogs(),
4310+ (Error.prepareStackTrace = frame);
4311+ }
4312+ sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "")
4313+ ? describeBuiltInComponentFrame(sampleLines)
4314+ : "";
4315+ "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
4316+ return sampleLines;
4317+ }
4318+ function describeComponentStackByType(type) {
4319+ if ("string" === typeof type) return describeBuiltInComponentFrame(type);
4320+ if ("function" === typeof type)
4321+ return type.prototype && type.prototype.isReactComponent
4322+ ? describeNativeComponentFrame(type, !0)
4323+ : describeNativeComponentFrame(type, !1);
4324+ if ("object" === typeof type && null !== type) {
4325+ switch (type.$$typeof) {
4326+ case REACT_FORWARD_REF_TYPE:
4327+ return describeNativeComponentFrame(type.render, !1);
4328+ case REACT_MEMO_TYPE:
4329+ return describeNativeComponentFrame(type.type, !1);
4330+ case REACT_LAZY_TYPE:
4331+ var lazyComponent = type,
4332+ payload = lazyComponent._payload;
4333+ lazyComponent = lazyComponent._init;
61344334 try {
6135− resolvedNode = init(payload);
4335+ type = lazyComponent(payload);
61364336 } catch (x) {
6137− if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
6138− // this Lazy initializer is suspending. push a temporary frame onto the stack so it can be
6139− // popped off in spawnNewSuspendedTask. This aligns stack behavior between Lazy in element position
6140− // vs Component position. We do not want the frame for Errors so we exclusively do this in
6141− // the wakeable branch
6142− pushBuiltInComponentStackInDEV(task, 'Lazy');
4337+ return describeBuiltInComponentFrame("Lazy");
4338+ }
4339+ return describeComponentStackByType(type);
4340+ }
4341+ if ("string" === typeof type.name) {
4342+ a: {
4343+ payload = type.name;
4344+ lazyComponent = type.env;
4345+ type = type.debugLocation;
4346+ if (null != type) {
4347+ type = formatOwnerStack(type);
4348+ var idx = type.lastIndexOf("\n");
4349+ type = -1 === idx ? type : type.slice(idx + 1);
4350+ if (-1 !== type.indexOf(payload)) {
4351+ payload = "\n" + type;
4352+ break a;
61434353 }
6144−
6145− throw x;
61464354 }
4355+ payload = describeBuiltInComponentFrame(
4356+ payload + (lazyComponent ? " [" + lazyComponent + "]" : "")
4357+ );
61474358 }
6148−
6149− renderNodeDestructive(request, task, resolvedNode);
6150− return;
4359+ return payload;
61514360 }
6152− }
6153−
6154− if (isArray(node)) {
6155− renderChildrenArray(request, task, node);
6156− return;
6157− }
6158−
6159− var iteratorFn = getIteratorFn(node);
6160−
6161− if (iteratorFn) {
6162− {
6163− validateIterable(node, iteratorFn);
61644361 }
6165−
6166− var iterator = iteratorFn.call(node);
6167−
6168− if (iterator) {
6169− // We need to know how many total children are in this set, so that we
6170− // can allocate enough id slots to acommodate them. So we must exhaust
6171− // the iterator before we start recursively rendering the children.
6172− // TODO: This is not great but I think it's inherent to the id
6173− // generation algorithm.
6174− var step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
6175−
6176− if (!step.done) {
6177− var children = [];
6178−
6179− do {
6180− children.push(step.value);
6181− step = iterator.next();
6182− } while (!step.done);
6183−
6184− renderChildrenArray(request, task, children);
6185− return;
4362+ switch (type) {
4363+ case REACT_SUSPENSE_LIST_TYPE:
4364+ return describeBuiltInComponentFrame("SuspenseList");
4365+ case REACT_SUSPENSE_TYPE:
4366+ return describeBuiltInComponentFrame("Suspense");
4367+ }
4368+ return "";
4369+ }
4370+ function isEligibleForOutlining(request, boundary) {
4371+ return (
4372+ (500 < boundary.byteSize || !1) && null === boundary.contentPreamble
4373+ );
4374+ }
4375+ function defaultErrorHandler(error) {
4376+ if (
4377+ "object" === typeof error &&
4378+ null !== error &&
4379+ "string" === typeof error.environmentName
4380+ ) {
4381+ var JSCompiler_inline_result = error.environmentName;
4382+ error = [error].slice(0);
4383+ "string" === typeof error[0]
4384+ ? error.splice(
4385+ 0,
4386+ 1,
4387+ "[%s] " + error[0],
4388+ " " + JSCompiler_inline_result + " "
4389+ )
4390+ : error.splice(0, 0, "[%s]", " " + JSCompiler_inline_result + " ");
4391+ error.unshift(console);
4392+ JSCompiler_inline_result = bind.apply(console.error, error);
4393+ JSCompiler_inline_result();
4394+ } else console.error(error);
4395+ return null;
4396+ }
4397+ function RequestInstance(
4398+ resumableState,
4399+ renderState,
4400+ rootFormatContext,
4401+ progressiveChunkSize,
4402+ onError,
4403+ onAllReady,
4404+ onShellReady,
4405+ onShellError,
4406+ onFatalError,
4407+ onPostpone,
4408+ formState
4409+ ) {
4410+ var abortSet = new Set();
4411+ this.destination = null;
4412+ this.flushScheduled = !1;
4413+ this.resumableState = resumableState;
4414+ this.renderState = renderState;
4415+ this.rootFormatContext = rootFormatContext;
4416+ this.progressiveChunkSize =
4417+ void 0 === progressiveChunkSize ? 12800 : progressiveChunkSize;
4418+ this.status = 10;
4419+ this.fatalError = null;
4420+ this.pendingRootTasks = this.allPendingTasks = this.nextSegmentId = 0;
4421+ this.completedPreambleSegments = this.completedRootSegment = null;
4422+ this.byteSize = 0;
4423+ this.abortableTasks = abortSet;
4424+ this.pingedTasks = [];
4425+ this.clientRenderedBoundaries = [];
4426+ this.completedBoundaries = [];
4427+ this.partialBoundaries = [];
4428+ this.trackedPostpones = null;
4429+ this.onError = void 0 === onError ? defaultErrorHandler : onError;
4430+ this.onPostpone = void 0 === onPostpone ? noop : onPostpone;
4431+ this.onAllReady = void 0 === onAllReady ? noop : onAllReady;
4432+ this.onShellReady = void 0 === onShellReady ? noop : onShellReady;
4433+ this.onShellError = void 0 === onShellError ? noop : onShellError;
4434+ this.onFatalError = void 0 === onFatalError ? noop : onFatalError;
4435+ this.formState = void 0 === formState ? null : formState;
4436+ this.didWarnForKey = null;
4437+ }
4438+ function createRequest(
4439+ children,
4440+ resumableState,
4441+ renderState,
4442+ rootFormatContext,
4443+ progressiveChunkSize,
4444+ onError,
4445+ onAllReady,
4446+ onShellReady,
4447+ onShellError,
4448+ onFatalError,
4449+ onPostpone,
4450+ formState
4451+ ) {
4452+ var now = getCurrentTime();
4453+ 1e3 < now - lastResetTime &&
4454+ ((ReactSharedInternals.recentlyCreatedOwnerStacks = 0),
4455+ (lastResetTime = now));
4456+ resumableState = new RequestInstance(
4457+ resumableState,
4458+ renderState,
4459+ rootFormatContext,
4460+ progressiveChunkSize,
4461+ onError,
4462+ onAllReady,
4463+ onShellReady,
4464+ onShellError,
4465+ onFatalError,
4466+ onPostpone,
4467+ formState
4468+ );
4469+ renderState = createPendingSegment(
4470+ resumableState,
4471+ 0,
4472+ null,
4473+ rootFormatContext,
4474+ !1,
4475+ !1
4476+ );
4477+ renderState.parentFlushed = !0;
4478+ children = createRenderTask(
4479+ resumableState,
4480+ null,
4481+ children,
4482+ -1,
4483+ null,
4484+ renderState,
4485+ null,
4486+ null,
4487+ resumableState.abortableTasks,
4488+ null,
4489+ rootFormatContext,
4490+ null,
4491+ emptyTreeContext,
4492+ null,
4493+ null,
4494+ emptyContextObject,
4495+ null
4496+ );
4497+ pushComponentStack(children);
4498+ resumableState.pingedTasks.push(children);
4499+ return resumableState;
4500+ }
4501+ function pingTask(request, task) {
4502+ request.pingedTasks.push(task);
4503+ 1 === request.pingedTasks.length &&
4504+ ((request.flushScheduled = null !== request.destination),
4505+ performWork(request));
4506+ }
4507+ function createSuspenseBoundary(
4508+ request,
4509+ row,
4510+ fallbackAbortableTasks,
4511+ contentPreamble,
4512+ fallbackPreamble
4513+ ) {
4514+ fallbackAbortableTasks = {
4515+ status: PENDING,
4516+ rootSegmentID: -1,
4517+ parentFlushed: !1,
4518+ pendingTasks: 0,
4519+ row: row,
4520+ completedSegments: [],
4521+ byteSize: 0,
4522+ fallbackAbortableTasks: fallbackAbortableTasks,
4523+ errorDigest: null,
4524+ contentState: createHoistableState(),
4525+ fallbackState: createHoistableState(),
4526+ contentPreamble: contentPreamble,
4527+ fallbackPreamble: fallbackPreamble,
4528+ trackedContentKeyPath: null,
4529+ trackedFallbackNode: null,
4530+ errorMessage: null,
4531+ errorStack: null,
4532+ errorComponentStack: null
4533+ };
4534+ null !== row &&
4535+ (row.pendingTasks++,
4536+ (contentPreamble = row.boundaries),
4537+ null !== contentPreamble &&
4538+ (request.allPendingTasks++,
4539+ fallbackAbortableTasks.pendingTasks++,
4540+ contentPreamble.push(fallbackAbortableTasks)),
4541+ (request = row.inheritedHoistables),
4542+ null !== request &&
4543+ hoistHoistables(fallbackAbortableTasks.contentState, request));
4544+ return fallbackAbortableTasks;
4545+ }
4546+ function createRenderTask(
4547+ request,
4548+ thenableState,
4549+ node,
4550+ childIndex,
4551+ blockedBoundary,
4552+ blockedSegment,
4553+ blockedPreamble,
4554+ hoistableState,
4555+ abortSet,
4556+ keyPath,
4557+ formatContext,
4558+ context,
4559+ treeContext,
4560+ row,
4561+ componentStack,
4562+ legacyContext,
4563+ debugTask
4564+ ) {
4565+ request.allPendingTasks++;
4566+ null === blockedBoundary
4567+ ? request.pendingRootTasks++
4568+ : blockedBoundary.pendingTasks++;
4569+ null !== row && row.pendingTasks++;
4570+ var task = {
4571+ replay: null,
4572+ node: node,
4573+ childIndex: childIndex,
4574+ ping: function () {
4575+ return pingTask(request, task);
4576+ },
4577+ blockedBoundary: blockedBoundary,
4578+ blockedSegment: blockedSegment,
4579+ blockedPreamble: blockedPreamble,
4580+ hoistableState: hoistableState,
4581+ abortSet: abortSet,
4582+ keyPath: keyPath,
4583+ formatContext: formatContext,
4584+ context: context,
4585+ treeContext: treeContext,
4586+ row: row,
4587+ componentStack: componentStack,
4588+ thenableState: thenableState
4589+ };
4590+ task.debugTask = debugTask;
4591+ abortSet.add(task);
4592+ return task;
4593+ }
4594+ function createReplayTask(
4595+ request,
4596+ thenableState,
4597+ replay,
4598+ node,
4599+ childIndex,
4600+ blockedBoundary,
4601+ hoistableState,
4602+ abortSet,
4603+ keyPath,
4604+ formatContext,
4605+ context,
4606+ treeContext,
4607+ row,
4608+ componentStack,
4609+ legacyContext,
4610+ debugTask
4611+ ) {
4612+ request.allPendingTasks++;
4613+ null === blockedBoundary
4614+ ? request.pendingRootTasks++
4615+ : blockedBoundary.pendingTasks++;
4616+ null !== row && row.pendingTasks++;
4617+ replay.pendingTasks++;
4618+ var task = {
4619+ replay: replay,
4620+ node: node,
4621+ childIndex: childIndex,
4622+ ping: function () {
4623+ return pingTask(request, task);
4624+ },
4625+ blockedBoundary: blockedBoundary,
4626+ blockedSegment: null,
4627+ blockedPreamble: null,
4628+ hoistableState: hoistableState,
4629+ abortSet: abortSet,
4630+ keyPath: keyPath,
4631+ formatContext: formatContext,
4632+ context: context,
4633+ treeContext: treeContext,
4634+ row: row,
4635+ componentStack: componentStack,
4636+ thenableState: thenableState
4637+ };
4638+ task.debugTask = debugTask;
4639+ abortSet.add(task);
4640+ return task;
4641+ }
4642+ function createPendingSegment(
4643+ request,
4644+ index,
4645+ boundary,
4646+ parentFormatContext,
4647+ lastPushedText,
4648+ textEmbedded
4649+ ) {
4650+ return {
4651+ status: PENDING,
4652+ parentFlushed: !1,
4653+ id: -1,
4654+ index: index,
4655+ chunks: [],
4656+ children: [],
4657+ preambleChildren: [],
4658+ parentFormatContext: parentFormatContext,
4659+ boundary: boundary,
4660+ lastPushedText: lastPushedText,
4661+ textEmbedded: textEmbedded
4662+ };
4663+ }
4664+ function getCurrentStackInDEV() {
4665+ if (null === currentTaskInDEV || null === currentTaskInDEV.componentStack)
4666+ return "";
4667+ var componentStack = currentTaskInDEV.componentStack;
4668+ try {
4669+ var info = "";
4670+ if ("string" === typeof componentStack.type)
4671+ info += describeBuiltInComponentFrame(componentStack.type);
4672+ else if ("function" === typeof componentStack.type) {
4673+ if (!componentStack.owner) {
4674+ var JSCompiler_temp_const = info,
4675+ fn = componentStack.type,
4676+ name = fn ? fn.displayName || fn.name : "";
4677+ var JSCompiler_inline_result = name
4678+ ? describeBuiltInComponentFrame(name)
4679+ : "";
4680+ info = JSCompiler_temp_const + JSCompiler_inline_result;
4681+ }
4682+ } else
4683+ componentStack.owner ||
4684+ (info += describeComponentStackByType(componentStack.type));
4685+ for (; componentStack; )
4686+ (JSCompiler_temp_const = null),
4687+ null != componentStack.debugStack
4688+ ? (JSCompiler_temp_const = formatOwnerStack(
4689+ componentStack.debugStack
4690+ ))
4691+ : ((JSCompiler_inline_result = componentStack),
4692+ null != JSCompiler_inline_result.stack &&
4693+ (JSCompiler_temp_const =
4694+ "string" !== typeof JSCompiler_inline_result.stack
4695+ ? (JSCompiler_inline_result.stack = formatOwnerStack(
4696+ JSCompiler_inline_result.stack
4697+ ))
4698+ : JSCompiler_inline_result.stack)),
4699+ (componentStack = componentStack.owner) &&
4700+ JSCompiler_temp_const &&
4701+ (info += "\n" + JSCompiler_temp_const);
4702+ var JSCompiler_inline_result$jscomp$0 = info;
4703+ } catch (x) {
4704+ JSCompiler_inline_result$jscomp$0 =
4705+ "\nError generating stack: " + x.message + "\n" + x.stack;
4706+ }
4707+ return JSCompiler_inline_result$jscomp$0;
4708+ }
4709+ function pushHaltedAwaitOnComponentStack(task, debugInfo) {
4710+ if (null != debugInfo)
4711+ for (var i = debugInfo.length - 1; 0 <= i; i--) {
4712+ var info = debugInfo[i];
4713+ if ("string" === typeof info.name) break;
4714+ if ("number" === typeof info.time) break;
4715+ if (null != info.awaited) {
4716+ var bestStack = null == info.debugStack ? info.awaited : info;
4717+ if (void 0 !== bestStack.debugStack) {
4718+ task.componentStack = {
4719+ parent: task.componentStack,
4720+ type: info,
4721+ owner: bestStack.owner,
4722+ stack: bestStack.debugStack
4723+ };
4724+ task.debugTask = bestStack.debugTask;
4725+ break;
4726+ }
4727+ }
61864728 }
6187−
6188− return;
6189− }
6190− }
6191−
6192− var childString = Object.prototype.toString.call(node);
6193− throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
6194− }
6195−
6196− if (typeof node === 'string') {
6197− var segment = task.blockedSegment;
6198− segment.lastPushedText = pushTextInstance$1(task.blockedSegment.chunks, node, request.responseState, segment.lastPushedText);
6199− return;
6200− }
6201−
6202− if (typeof node === 'number') {
6203− var _segment = task.blockedSegment;
6204− _segment.lastPushedText = pushTextInstance$1(task.blockedSegment.chunks, '' + node, request.responseState, _segment.lastPushedText);
6205− return;
6206− }
6207−
6208− {
6209− if (typeof node === 'function') {
6210− error('Functions are not valid as a React child. This may happen if ' + 'you return a Component instead of <Component /> from render. ' + 'Or maybe you meant to call this function rather than return it.');
6211− }
6212− }
6213−}
6214−
6215−function renderChildrenArray(request, task, children) {
6216− var totalChildren = children.length;
6217−
6218− for (var i = 0; i < totalChildren; i++) {
6219− var prevTreeContext = task.treeContext;
6220− task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i);
6221−
6222− try {
6223− // We need to use the non-destructive form so that we can safely pop back
6224− // up and render the sibling if something suspends.
6225− renderNode(request, task, children[i]);
6226− } finally {
6227− task.treeContext = prevTreeContext;
62284729 }
6229− }
6230−}
6231−
6232−function spawnNewSuspendedTask(request, task, x) {
6233− // Something suspended, we'll need to create a new segment and resolve it later.
6234− var segment = task.blockedSegment;
6235− var insertionIndex = segment.chunks.length;
6236− var newSegment = createPendingSegment(request, insertionIndex, null, segment.formatContext, // Adopt the parent segment's leading text embed
6237− segment.lastPushedText, // Assume we are text embedded at the trailing edge
6238− true);
6239− segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
6240−
6241− segment.lastPushedText = false;
6242− var newTask = createTask(request, task.node, task.blockedBoundary, newSegment, task.abortSet, task.legacyContext, task.context, task.treeContext);
6243−
6244− {
6245− if (task.componentStack !== null) {
6246− // We pop one task off the stack because the node that suspended will be tried again,
6247− // which will add it back onto the stack.
6248− newTask.componentStack = task.componentStack.parent;
4730+ function pushServerComponentStack(task, debugInfo) {
4731+ if (null != debugInfo)
4732+ for (var i = 0; i < debugInfo.length; i++) {
4733+ var componentInfo = debugInfo[i];
4734+ "string" === typeof componentInfo.name &&
4735+ void 0 !== componentInfo.debugStack &&
4736+ ((task.componentStack = {
4737+ parent: task.componentStack,
4738+ type: componentInfo,
4739+ owner: componentInfo.owner,
4740+ stack: componentInfo.debugStack
4741+ }),
4742+ (task.debugTask = componentInfo.debugTask));
4743+ }
62494744 }
6250− }
6251−
6252− var ping = newTask.ping;
6253− x.then(ping, ping);
6254−} // This is a non-destructive form of rendering a node. If it suspends it spawns
6255−// a new task and restores the context of this task to what it was before.
6256−
6257−
6258−function renderNode(request, task, node) {
6259− // TODO: Store segment.children.length here and reset it in case something
6260− // suspended partially through writing something.
6261− // Snapshot the current context in case something throws to interrupt the
6262− // process.
6263− var previousFormatContext = task.blockedSegment.formatContext;
6264− var previousLegacyContext = task.legacyContext;
6265− var previousContext = task.context;
6266− var previousComponentStack = null;
6267−
6268− {
6269− previousComponentStack = task.componentStack;
6270− }
6271−
6272− try {
6273− return renderNodeDestructive(request, task, node);
6274− } catch (x) {
6275− resetHooksState();
6276−
6277− if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
6278− spawnNewSuspendedTask(request, task, x); // Restore the context. We assume that this will be restored by the inner
6279− // functions in case nothing throws so we don't use "finally" here.
6280−
6281− task.blockedSegment.formatContext = previousFormatContext;
6282− task.legacyContext = previousLegacyContext;
6283− task.context = previousContext; // Restore all active ReactContexts to what they were before.
6284−
6285− switchContext(previousContext);
6286−
6287− {
6288− task.componentStack = previousComponentStack;
6289− }
6290−
6291− return;
6292− } else {
6293− // Restore the context. We assume that this will be restored by the inner
6294− // functions in case nothing throws so we don't use "finally" here.
6295− task.blockedSegment.formatContext = previousFormatContext;
6296− task.legacyContext = previousLegacyContext;
6297− task.context = previousContext; // Restore all active ReactContexts to what they were before.
6298−
6299− switchContext(previousContext);
6300−
6301− {
6302− task.componentStack = previousComponentStack;
6303− } // We assume that we don't need the correct context.
6304− // Let's terminate the rest of the tree and don't render any siblings.
6305−
6306−
6307− throw x;
4745+ function pushComponentStack(task) {
4746+ var node = task.node;
4747+ if ("object" === typeof node && null !== node)
4748+ switch (node.$$typeof) {
4749+ case REACT_ELEMENT_TYPE:
4750+ var type = node.type,
4751+ owner = node._owner,
4752+ stack = node._debugStack;
4753+ pushServerComponentStack(task, node._debugInfo);
4754+ task.debugTask = node._debugTask;
4755+ task.componentStack = {
4756+ parent: task.componentStack,
4757+ type: type,
4758+ owner: owner,
4759+ stack: stack
4760+ };
4761+ break;
4762+ case REACT_LAZY_TYPE:
4763+ pushServerComponentStack(task, node._debugInfo);
4764+ break;
4765+ default:
4766+ "function" === typeof node.then &&
4767+ pushServerComponentStack(task, node._debugInfo);
4768+ }
63084769 }
6309− }
6310−}
6311−
6312−function erroredTask(request, boundary, segment, error) {
6313− // Report the error to a global handler.
6314− var errorDigest = logRecoverableError(request, error);
6315−
6316− if (boundary === null) {
6317− fatalError(request, error);
6318− } else {
6319− boundary.pendingTasks--;
6320−
6321− if (!boundary.forceClientRender) {
6322− boundary.forceClientRender = true;
6323− boundary.errorDigest = errorDigest;
6324−
6325− {
6326− captureBoundaryErrorDetailsDev(boundary, error);
6327− } // Regardless of what happens next, this boundary won't be displayed,
6328− // so we can flush it, if the parent already flushed.
6329−
6330−
6331− if (boundary.parentFlushed) {
6332− // We don't have a preference where in the queue this goes since it's likely
6333− // to error on the client anyway. However, intentionally client-rendered
6334− // boundaries should be flushed earlier so that they can start on the client.
6335− // We reuse the same queue for errors.
6336− request.clientRenderedBoundaries.push(boundary);
4770+ function replaceSuspenseComponentStackWithSuspenseFallbackStack(
4771+ componentStack
4772+ ) {
4773+ return null === componentStack
4774+ ? null
4775+ : {
4776+ parent: componentStack.parent,
4777+ type: "Suspense Fallback",
4778+ owner: componentStack.owner,
4779+ stack: componentStack.stack
4780+ };
4781+ }
4782+ function getThrownInfo(node$jscomp$0) {
4783+ var errorInfo = {};
4784+ node$jscomp$0 &&
4785+ Object.defineProperty(errorInfo, "componentStack", {
4786+ configurable: !0,
4787+ enumerable: !0,
4788+ get: function () {
4789+ try {
4790+ var info = "",
4791+ node = node$jscomp$0;
4792+ do
4793+ (info += describeComponentStackByType(node.type)),
4794+ (node = node.parent);
4795+ while (node);
4796+ var stack = info;
4797+ } catch (x) {
4798+ stack = "\nError generating stack: " + x.message + "\n" + x.stack;
4799+ }
4800+ Object.defineProperty(errorInfo, "componentStack", {
4801+ value: stack
4802+ });
4803+ return stack;
4804+ }
4805+ });
4806+ return errorInfo;
4807+ }
4808+ function encodeErrorForBoundary(
4809+ boundary,
4810+ digest,
4811+ error,
4812+ thrownInfo,
4813+ wasAborted
4814+ ) {
4815+ boundary.errorDigest = digest;
4816+ error instanceof Error
4817+ ? ((digest = String(error.message)), (error = String(error.stack)))
4818+ : ((digest =
4819+ "object" === typeof error && null !== error
4820+ ? describeObjectForErrorMessage(error)
4821+ : String(error)),
4822+ (error = null));
4823+ wasAborted = wasAborted
4824+ ? "Switched to client rendering because the server rendering aborted due to:\n\n"
4825+ : "Switched to client rendering because the server rendering errored:\n\n";
4826+ boundary.errorMessage = wasAborted + digest;
4827+ boundary.errorStack = null !== error ? wasAborted + error : null;
4828+ boundary.errorComponentStack = thrownInfo.componentStack;
4829+ }
4830+ function logRecoverableError(request, error, errorInfo, debugTask) {
4831+ request = request.onError;
4832+ error = debugTask
4833+ ? debugTask.run(request.bind(null, error, errorInfo))
4834+ : request(error, errorInfo);
4835+ if (null != error && "string" !== typeof error)
4836+ console.error(
4837+ 'onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "%s" instead',
4838+ typeof error
4839+ );
4840+ else return error;
4841+ }
4842+ function fatalError(request, error, errorInfo, debugTask) {
4843+ errorInfo = request.onShellError;
4844+ var onFatalError = request.onFatalError;
4845+ debugTask
4846+ ? (debugTask.run(errorInfo.bind(null, error)),
4847+ debugTask.run(onFatalError.bind(null, error)))
4848+ : (errorInfo(error), onFatalError(error));
4849+ null !== request.destination
4850+ ? ((request.status = CLOSED), request.destination.destroy(error))
4851+ : ((request.status = 13), (request.fatalError = error));
4852+ }
4853+ function finishSuspenseListRow(request, row) {
4854+ unblockSuspenseListRow(request, row.next, row.hoistables);
4855+ }
4856+ function unblockSuspenseListRow(
4857+ request,
4858+ unblockedRow,
4859+ inheritedHoistables
4860+ ) {
4861+ for (; null !== unblockedRow; ) {
4862+ null !== inheritedHoistables &&
4863+ (hoistHoistables(unblockedRow.hoistables, inheritedHoistables),
4864+ (unblockedRow.inheritedHoistables = inheritedHoistables));
4865+ var unblockedBoundaries = unblockedRow.boundaries;
4866+ if (null !== unblockedBoundaries) {
4867+ unblockedRow.boundaries = null;
4868+ for (var i = 0; i < unblockedBoundaries.length; i++) {
4869+ var unblockedBoundary = unblockedBoundaries[i];
4870+ null !== inheritedHoistables &&
4871+ hoistHoistables(
4872+ unblockedBoundary.contentState,
4873+ inheritedHoistables
4874+ );
4875+ finishedTask(request, unblockedBoundary, null, null);
4876+ }
4877+ }
4878+ unblockedRow.pendingTasks--;
4879+ if (0 < unblockedRow.pendingTasks) break;
4880+ inheritedHoistables = unblockedRow.hoistables;
4881+ unblockedRow = unblockedRow.next;
4882+ }
4883+ }
4884+ function tryToResolveTogetherRow(request, togetherRow) {
4885+ var boundaries = togetherRow.boundaries;
4886+ if (
4887+ null !== boundaries &&
4888+ togetherRow.pendingTasks === boundaries.length
4889+ ) {
4890+ for (
4891+ var allCompleteAndInlinable = !0, i = 0;
4892+ i < boundaries.length;
4893+ i++
4894+ ) {
4895+ var rowBoundary = boundaries[i];
4896+ if (
4897+ 1 !== rowBoundary.pendingTasks ||
4898+ rowBoundary.parentFlushed ||
4899+ isEligibleForOutlining(request, rowBoundary)
4900+ ) {
4901+ allCompleteAndInlinable = !1;
4902+ break;
4903+ }
4904+ }
4905+ allCompleteAndInlinable &&
4906+ unblockSuspenseListRow(request, togetherRow, togetherRow.hoistables);
4907+ }
4908+ }
4909+ function createSuspenseListRow(previousRow) {
4910+ var newRow = {
4911+ pendingTasks: 1,
4912+ boundaries: null,
4913+ hoistables: createHoistableState(),
4914+ inheritedHoistables: null,
4915+ together: !1,
4916+ next: null
4917+ };
4918+ null !== previousRow &&
4919+ 0 < previousRow.pendingTasks &&
4920+ (newRow.pendingTasks++,
4921+ (newRow.boundaries = []),
4922+ (previousRow.next = newRow));
4923+ return newRow;
4924+ }
4925+ function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
4926+ var prevKeyPath = task.keyPath,
4927+ prevTreeContext = task.treeContext,
4928+ prevRow = task.row,
4929+ previousComponentStack = task.componentStack;
4930+ var previousDebugTask = task.debugTask;
4931+ pushServerComponentStack(task, task.node.props.children._debugInfo);
4932+ task.keyPath = keyPath;
4933+ keyPath = rows.length;
4934+ var previousSuspenseListRow = null;
4935+ if (null !== task.replay) {
4936+ var resumeSlots = task.replay.slots;
4937+ if (null !== resumeSlots && "object" === typeof resumeSlots)
4938+ for (var n = 0; n < keyPath; n++) {
4939+ var i =
4940+ "backwards" !== revealOrder &&
4941+ "unstable_legacy-backwards" !== revealOrder
4942+ ? n
4943+ : keyPath - 1 - n,
4944+ node = rows[i];
4945+ task.row = previousSuspenseListRow = createSuspenseListRow(
4946+ previousSuspenseListRow
4947+ );
4948+ task.treeContext = pushTreeContext(prevTreeContext, keyPath, i);
4949+ var resumeSegmentID = resumeSlots[i];
4950+ "number" === typeof resumeSegmentID
4951+ ? (resumeNode(request, task, resumeSegmentID, node, i),
4952+ delete resumeSlots[i])
4953+ : renderNode(request, task, node, i);
4954+ 0 === --previousSuspenseListRow.pendingTasks &&
4955+ finishSuspenseListRow(request, previousSuspenseListRow);
4956+ }
4957+ else
4958+ for (resumeSlots = 0; resumeSlots < keyPath; resumeSlots++)
4959+ (n =
4960+ "backwards" !== revealOrder &&
4961+ "unstable_legacy-backwards" !== revealOrder
4962+ ? resumeSlots
4963+ : keyPath - 1 - resumeSlots),
4964+ (i = rows[n]),
4965+ warnForMissingKey(request, task, i),
4966+ (task.row = previousSuspenseListRow =
4967+ createSuspenseListRow(previousSuspenseListRow)),
4968+ (task.treeContext = pushTreeContext(prevTreeContext, keyPath, n)),
4969+ renderNode(request, task, i, n),
4970+ 0 === --previousSuspenseListRow.pendingTasks &&
4971+ finishSuspenseListRow(request, previousSuspenseListRow);
4972+ } else if (
4973+ "backwards" !== revealOrder &&
4974+ "unstable_legacy-backwards" !== revealOrder
4975+ )
4976+ for (revealOrder = 0; revealOrder < keyPath; revealOrder++)
4977+ (resumeSlots = rows[revealOrder]),
4978+ warnForMissingKey(request, task, resumeSlots),
4979+ (task.row = previousSuspenseListRow =
4980+ createSuspenseListRow(previousSuspenseListRow)),
4981+ (task.treeContext = pushTreeContext(
4982+ prevTreeContext,
4983+ keyPath,
4984+ revealOrder
4985+ )),
4986+ renderNode(request, task, resumeSlots, revealOrder),
4987+ 0 === --previousSuspenseListRow.pendingTasks &&
4988+ finishSuspenseListRow(request, previousSuspenseListRow);
4989+ else {
4990+ revealOrder = task.blockedSegment;
4991+ resumeSlots = revealOrder.children.length;
4992+ n = revealOrder.chunks.length;
4993+ for (i = keyPath - 1; 0 <= i; i--) {
4994+ node = rows[i];
4995+ task.row = previousSuspenseListRow = createSuspenseListRow(
4996+ previousSuspenseListRow
4997+ );
4998+ task.treeContext = pushTreeContext(prevTreeContext, keyPath, i);
4999+ resumeSegmentID = createPendingSegment(
5000+ request,
5001+ n,
5002+ null,
5003+ task.formatContext,
5004+ 0 === i ? revealOrder.lastPushedText : !0,
5005+ !0
5006+ );
5007+ revealOrder.children.splice(resumeSlots, 0, resumeSegmentID);
5008+ task.blockedSegment = resumeSegmentID;
5009+ warnForMissingKey(request, task, node);
5010+ try {
5011+ renderNode(request, task, node, i),
5012+ pushSegmentFinale(
5013+ resumeSegmentID.chunks,
5014+ request.renderState,
5015+ resumeSegmentID.lastPushedText,
5016+ resumeSegmentID.textEmbedded
5017+ ),
5018+ (resumeSegmentID.status = COMPLETED),
5019+ 0 === --previousSuspenseListRow.pendingTasks &&
5020+ finishSuspenseListRow(request, previousSuspenseListRow);
5021+ } catch (thrownValue) {
5022+ throw (
5023+ ((resumeSegmentID.status =
5024+ 12 === request.status ? ABORTED : ERRORED),
5025+ thrownValue)
5026+ );
5027+ }
5028+ }
5029+ task.blockedSegment = revealOrder;
5030+ revealOrder.lastPushedText = !1;
63375031 }
6338− }
6339− }
6340−
6341− request.allPendingTasks--;
6342−
6343− if (request.allPendingTasks === 0) {
6344− var onAllReady = request.onAllReady;
6345− onAllReady();
6346− }
6347−}
6348−
6349−function abortTaskSoft(task) {
6350− // This aborts task without aborting the parent boundary that it blocks.
6351− // It's used for when we didn't need this task to complete the tree.
6352− // If task was needed, then it should use abortTask instead.
6353− var request = this;
6354− var boundary = task.blockedBoundary;
6355− var segment = task.blockedSegment;
6356− segment.status = ABORTED;
6357− finishedTask(request, boundary, segment);
6358−}
6359−
6360−function abortTask(task, request, reason) {
6361− // This aborts the task and aborts the parent that it blocks, putting it into
6362− // client rendered mode.
6363− var boundary = task.blockedBoundary;
6364− var segment = task.blockedSegment;
6365− segment.status = ABORTED;
6366−
6367− if (boundary === null) {
6368− request.allPendingTasks--; // We didn't complete the root so we have nothing to show. We can close
6369− // the request;
6370−
6371− if (request.status !== CLOSED) {
6372− request.status = CLOSED;
6373−
6374− if (request.destination !== null) {
6375− close(request.destination);
5032+ null !== prevRow &&
5033+ null !== previousSuspenseListRow &&
5034+ 0 < previousSuspenseListRow.pendingTasks &&
5035+ (prevRow.pendingTasks++, (previousSuspenseListRow.next = prevRow));
5036+ task.treeContext = prevTreeContext;
5037+ task.row = prevRow;
5038+ task.keyPath = prevKeyPath;
5039+ task.componentStack = previousComponentStack;
5040+ task.debugTask = previousDebugTask;
5041+ }
5042+ function renderWithHooks(
5043+ request,
5044+ task,
5045+ keyPath,
5046+ Component,
5047+ props,
5048+ secondArg
5049+ ) {
5050+ var prevThenableState = task.thenableState;
5051+ task.thenableState = null;
5052+ currentlyRenderingComponent = {};
5053+ currentlyRenderingTask = task;
5054+ currentlyRenderingRequest = request;
5055+ currentlyRenderingKeyPath = keyPath;
5056+ isInHookUserCodeInDev = !1;
5057+ actionStateCounter = localIdCounter = 0;
5058+ actionStateMatchingIndex = -1;
5059+ thenableIndexCounter = 0;
5060+ thenableState = prevThenableState;
5061+ for (
5062+ request = callComponentInDEV(Component, props, secondArg);
5063+ didScheduleRenderPhaseUpdate;
5064+
5065+ )
5066+ (didScheduleRenderPhaseUpdate = !1),
5067+ (actionStateCounter = localIdCounter = 0),
5068+ (actionStateMatchingIndex = -1),
5069+ (thenableIndexCounter = 0),
5070+ (numberOfReRenders += 1),
5071+ (workInProgressHook = null),
5072+ (request = Component(props, secondArg));
5073+ resetHooksState();
5074+ return request;
5075+ }
5076+ function finishFunctionComponent(
5077+ request,
5078+ task,
5079+ keyPath,
5080+ children,
5081+ hasId,
5082+ actionStateCount,
5083+ actionStateMatchingIndex
5084+ ) {
5085+ var didEmitActionStateMarkers = !1;
5086+ if (0 !== actionStateCount && null !== request.formState) {
5087+ var segment = task.blockedSegment;
5088+ if (null !== segment) {
5089+ didEmitActionStateMarkers = !0;
5090+ segment = segment.chunks;
5091+ for (var i = 0; i < actionStateCount; i++)
5092+ i === actionStateMatchingIndex
5093+ ? segment.push("\x3c!--F!--\x3e")
5094+ : segment.push("\x3c!--F--\x3e");
5095+ }
63765096 }
6377− }
6378− } else {
6379− boundary.pendingTasks--;
6380−
6381− if (!boundary.forceClientRender) {
6382− boundary.forceClientRender = true;
6383−
6384− var _error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
6385−
6386− boundary.errorDigest = request.onError(_error);
6387−
6388− {
6389− var errorPrefix = 'The server did not finish this Suspense boundary: ';
6390−
6391− if (_error && typeof _error.message === 'string') {
6392− _error = errorPrefix + _error.message;
5097+ actionStateCount = task.keyPath;
5098+ task.keyPath = keyPath;
5099+ hasId
5100+ ? ((keyPath = task.treeContext),
5101+ (task.treeContext = pushTreeContext(keyPath, 1, 0)),
5102+ renderNode(request, task, children, -1),
5103+ (task.treeContext = keyPath))
5104+ : didEmitActionStateMarkers
5105+ ? renderNode(request, task, children, -1)
5106+ : renderNodeDestructive(request, task, children, -1);
5107+ task.keyPath = actionStateCount;
5108+ }
5109+ function renderElement(request, task, keyPath, type, props, ref) {
5110+ if ("function" === typeof type)
5111+ if (type.prototype && type.prototype.isReactComponent) {
5112+ var newProps = props;
5113+ if ("ref" in props) {
5114+ newProps = {};
5115+ for (var propName in props)
5116+ "ref" !== propName && (newProps[propName] = props[propName]);
5117+ }
5118+ var defaultProps = type.defaultProps;
5119+ if (defaultProps) {
5120+ newProps === props && (newProps = assign({}, newProps, props));
5121+ for (var _propName in defaultProps)
5122+ void 0 === newProps[_propName] &&
5123+ (newProps[_propName] = defaultProps[_propName]);
5124+ }
5125+ var resolvedProps = newProps;
5126+ var context = emptyContextObject,
5127+ contextType = type.contextType;
5128+ if (
5129+ "contextType" in type &&
5130+ null !== contextType &&
5131+ (void 0 === contextType ||
5132+ contextType.$$typeof !== REACT_CONTEXT_TYPE) &&
5133+ !didWarnAboutInvalidateContextType.has(type)
5134+ ) {
5135+ didWarnAboutInvalidateContextType.add(type);
5136+ var addendum =
5137+ void 0 === contextType
5138+ ? " However, it is set to undefined. This can be caused by a typo or by mixing up named and default imports. This can also happen due to a circular dependency, so try moving the createContext() call to a separate file."
5139+ : "object" !== typeof contextType
5140+ ? " However, it is set to a " + typeof contextType + "."
5141+ : contextType.$$typeof === REACT_CONSUMER_TYPE
5142+ ? " Did you accidentally pass the Context.Consumer instead?"
5143+ : " However, it is set to an object with keys {" +
5144+ Object.keys(contextType).join(", ") +
5145+ "}.";
5146+ console.error(
5147+ "%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s",
5148+ getComponentNameFromType(type) || "Component",
5149+ addendum
5150+ );
5151+ }
5152+ "object" === typeof contextType &&
5153+ null !== contextType &&
5154+ (context = contextType._currentValue2);
5155+ var instance = new type(resolvedProps, context);
5156+ if (
5157+ "function" === typeof type.getDerivedStateFromProps &&
5158+ (null === instance.state || void 0 === instance.state)
5159+ ) {
5160+ var componentName = getComponentNameFromType(type) || "Component";
5161+ didWarnAboutUninitializedState.has(componentName) ||
5162+ (didWarnAboutUninitializedState.add(componentName),
5163+ console.error(
5164+ "`%s` uses `getDerivedStateFromProps` but its initial state is %s. This is not recommended. Instead, define the initial state by assigning an object to `this.state` in the constructor of `%s`. This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
5165+ componentName,
5166+ null === instance.state ? "null" : "undefined",
5167+ componentName
5168+ ));
5169+ }
5170+ if (
5171+ "function" === typeof type.getDerivedStateFromProps ||
5172+ "function" === typeof instance.getSnapshotBeforeUpdate
5173+ ) {
5174+ var foundWillMountName = null,
5175+ foundWillReceivePropsName = null,
5176+ foundWillUpdateName = null;
5177+ "function" === typeof instance.componentWillMount &&
5178+ !0 !== instance.componentWillMount.__suppressDeprecationWarning
5179+ ? (foundWillMountName = "componentWillMount")
5180+ : "function" === typeof instance.UNSAFE_componentWillMount &&
5181+ (foundWillMountName = "UNSAFE_componentWillMount");
5182+ "function" === typeof instance.componentWillReceiveProps &&
5183+ !0 !==
5184+ instance.componentWillReceiveProps.__suppressDeprecationWarning
5185+ ? (foundWillReceivePropsName = "componentWillReceiveProps")
5186+ : "function" ===
5187+ typeof instance.UNSAFE_componentWillReceiveProps &&
5188+ (foundWillReceivePropsName =
5189+ "UNSAFE_componentWillReceiveProps");
5190+ "function" === typeof instance.componentWillUpdate &&
5191+ !0 !== instance.componentWillUpdate.__suppressDeprecationWarning
5192+ ? (foundWillUpdateName = "componentWillUpdate")
5193+ : "function" === typeof instance.UNSAFE_componentWillUpdate &&
5194+ (foundWillUpdateName = "UNSAFE_componentWillUpdate");
5195+ if (
5196+ null !== foundWillMountName ||
5197+ null !== foundWillReceivePropsName ||
5198+ null !== foundWillUpdateName
5199+ ) {
5200+ var _componentName =
5201+ getComponentNameFromType(type) || "Component",
5202+ newApiName =
5203+ "function" === typeof type.getDerivedStateFromProps
5204+ ? "getDerivedStateFromProps()"
5205+ : "getSnapshotBeforeUpdate()";
5206+ didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName) ||
5207+ (didWarnAboutLegacyLifecyclesAndDerivedState.add(
5208+ _componentName
5209+ ),
5210+ console.error(
5211+ "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\nThe above lifecycles should be removed. Learn more about this warning here:\nhttps://react.dev/link/unsafe-component-lifecycles",
5212+ _componentName,
5213+ newApiName,
5214+ null !== foundWillMountName
5215+ ? "\n " + foundWillMountName
5216+ : "",
5217+ null !== foundWillReceivePropsName
5218+ ? "\n " + foundWillReceivePropsName
5219+ : "",
5220+ null !== foundWillUpdateName
5221+ ? "\n " + foundWillUpdateName
5222+ : ""
5223+ ));
5224+ }
5225+ }
5226+ var name = getComponentNameFromType(type) || "Component";
5227+ instance.render ||
5228+ (type.prototype && "function" === typeof type.prototype.render
5229+ ? console.error(
5230+ "No `render` method found on the %s instance: did you accidentally return an object from the constructor?",
5231+ name
5232+ )
5233+ : console.error(
5234+ "No `render` method found on the %s instance: you may have forgotten to define `render`.",
5235+ name
5236+ ));
5237+ !instance.getInitialState ||
5238+ instance.getInitialState.isReactClassApproved ||
5239+ instance.state ||
5240+ console.error(
5241+ "getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?",
5242+ name
5243+ );
5244+ instance.getDefaultProps &&
5245+ !instance.getDefaultProps.isReactClassApproved &&
5246+ console.error(
5247+ "getDefaultProps was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Use a static property to define defaultProps instead.",
5248+ name
5249+ );
5250+ instance.contextType &&
5251+ console.error(
5252+ "contextType was defined as an instance property on %s. Use a static property to define contextType instead.",
5253+ name
5254+ );
5255+ type.childContextTypes &&
5256+ !didWarnAboutChildContextTypes.has(type) &&
5257+ (didWarnAboutChildContextTypes.add(type),
5258+ console.error(
5259+ "%s uses the legacy childContextTypes API which was removed in React 19. Use React.createContext() instead. (https://react.dev/link/legacy-context)",
5260+ name
5261+ ));
5262+ type.contextTypes &&
5263+ !didWarnAboutContextTypes$1.has(type) &&
5264+ (didWarnAboutContextTypes$1.add(type),
5265+ console.error(
5266+ "%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with static contextType instead. (https://react.dev/link/legacy-context)",
5267+ name
5268+ ));
5269+ "function" === typeof instance.componentShouldUpdate &&
5270+ console.error(
5271+ "%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.",
5272+ name
5273+ );
5274+ type.prototype &&
5275+ type.prototype.isPureReactComponent &&
5276+ "undefined" !== typeof instance.shouldComponentUpdate &&
5277+ console.error(
5278+ "%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.",
5279+ getComponentNameFromType(type) || "A pure component"
5280+ );
5281+ "function" === typeof instance.componentDidUnmount &&
5282+ console.error(
5283+ "%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?",
5284+ name
5285+ );
5286+ "function" === typeof instance.componentDidReceiveProps &&
5287+ console.error(
5288+ "%s has a method called componentDidReceiveProps(). But there is no such lifecycle method. If you meant to update the state in response to changing props, use componentWillReceiveProps(). If you meant to fetch data or run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
5289+ name
5290+ );
5291+ "function" === typeof instance.componentWillRecieveProps &&
5292+ console.error(
5293+ "%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
5294+ name
5295+ );
5296+ "function" === typeof instance.UNSAFE_componentWillRecieveProps &&
5297+ console.error(
5298+ "%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
5299+ name
5300+ );
5301+ var hasMutatedProps = instance.props !== resolvedProps;
5302+ void 0 !== instance.props &&
5303+ hasMutatedProps &&
5304+ console.error(
5305+ "When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.",
5306+ name
5307+ );
5308+ instance.defaultProps &&
5309+ console.error(
5310+ "Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.",
5311+ name,
5312+ name
5313+ );
5314+ "function" !== typeof instance.getSnapshotBeforeUpdate ||
5315+ "function" === typeof instance.componentDidUpdate ||
5316+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(type) ||
5317+ (didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(type),
5318+ console.error(
5319+ "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.",
5320+ getComponentNameFromType(type)
5321+ ));
5322+ "function" === typeof instance.getDerivedStateFromProps &&
5323+ console.error(
5324+ "%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.",
5325+ name
5326+ );
5327+ "function" === typeof instance.getDerivedStateFromError &&
5328+ console.error(
5329+ "%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.",
5330+ name
5331+ );
5332+ "function" === typeof type.getSnapshotBeforeUpdate &&
5333+ console.error(
5334+ "%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.",
5335+ name
5336+ );
5337+ var state = instance.state;
5338+ state &&
5339+ ("object" !== typeof state || isArrayImpl(state)) &&
5340+ console.error("%s.state: must be set to an object or null", name);
5341+ "function" === typeof instance.getChildContext &&
5342+ "object" !== typeof type.childContextTypes &&
5343+ console.error(
5344+ "%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().",
5345+ name
5346+ );
5347+ var initialState = void 0 !== instance.state ? instance.state : null;
5348+ instance.updater = classComponentUpdater;
5349+ instance.props = resolvedProps;
5350+ instance.state = initialState;
5351+ var internalInstance = { queue: [], replace: !1 };
5352+ instance._reactInternals = internalInstance;
5353+ var contextType$jscomp$0 = type.contextType;
5354+ instance.context =
5355+ "object" === typeof contextType$jscomp$0 &&
5356+ null !== contextType$jscomp$0
5357+ ? contextType$jscomp$0._currentValue2
5358+ : emptyContextObject;
5359+ if (instance.state === resolvedProps) {
5360+ var componentName$jscomp$0 =
5361+ getComponentNameFromType(type) || "Component";
5362+ didWarnAboutDirectlyAssigningPropsToState.has(
5363+ componentName$jscomp$0
5364+ ) ||
5365+ (didWarnAboutDirectlyAssigningPropsToState.add(
5366+ componentName$jscomp$0
5367+ ),
5368+ console.error(
5369+ "%s: It is not recommended to assign props directly to state because updates to props won't be reflected in state. In most cases, it is better to use props directly.",
5370+ componentName$jscomp$0
5371+ ));
5372+ }
5373+ var getDerivedStateFromProps = type.getDerivedStateFromProps;
5374+ if ("function" === typeof getDerivedStateFromProps) {
5375+ var partialState = getDerivedStateFromProps(
5376+ resolvedProps,
5377+ initialState
5378+ );
5379+ if (void 0 === partialState) {
5380+ var componentName$jscomp$1 =
5381+ getComponentNameFromType(type) || "Component";
5382+ didWarnAboutUndefinedDerivedState.has(componentName$jscomp$1) ||
5383+ (didWarnAboutUndefinedDerivedState.add(componentName$jscomp$1),
5384+ console.error(
5385+ "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.",
5386+ componentName$jscomp$1
5387+ ));
5388+ }
5389+ var JSCompiler_inline_result =
5390+ null === partialState || void 0 === partialState
5391+ ? initialState
5392+ : assign({}, initialState, partialState);
5393+ instance.state = JSCompiler_inline_result;
5394+ }
5395+ if (
5396+ "function" !== typeof type.getDerivedStateFromProps &&
5397+ "function" !== typeof instance.getSnapshotBeforeUpdate &&
5398+ ("function" === typeof instance.UNSAFE_componentWillMount ||
5399+ "function" === typeof instance.componentWillMount)
5400+ ) {
5401+ var oldState = instance.state;
5402+ if ("function" === typeof instance.componentWillMount) {
5403+ if (
5404+ !0 !== instance.componentWillMount.__suppressDeprecationWarning
5405+ ) {
5406+ var componentName$jscomp$2 =
5407+ getComponentNameFromType(type) || "Unknown";
5408+ didWarnAboutDeprecatedWillMount[componentName$jscomp$2] ||
5409+ (console.warn(
5410+ "componentWillMount has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code from componentWillMount to componentDidMount (preferred in most cases) or the constructor.\n\nPlease update the following components: %s",
5411+ componentName$jscomp$2
5412+ ),
5413+ (didWarnAboutDeprecatedWillMount[componentName$jscomp$2] =
5414+ !0));
5415+ }
5416+ instance.componentWillMount();
5417+ }
5418+ "function" === typeof instance.UNSAFE_componentWillMount &&
5419+ instance.UNSAFE_componentWillMount();
5420+ oldState !== instance.state &&
5421+ (console.error(
5422+ "%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",
5423+ getComponentNameFromType(type) || "Component"
5424+ ),
5425+ classComponentUpdater.enqueueReplaceState(
5426+ instance,
5427+ instance.state,
5428+ null
5429+ ));
5430+ if (
5431+ null !== internalInstance.queue &&
5432+ 0 < internalInstance.queue.length
5433+ ) {
5434+ var oldQueue = internalInstance.queue,
5435+ oldReplace = internalInstance.replace;
5436+ internalInstance.queue = null;
5437+ internalInstance.replace = !1;
5438+ if (oldReplace && 1 === oldQueue.length)
5439+ instance.state = oldQueue[0];
5440+ else {
5441+ for (
5442+ var nextState = oldReplace ? oldQueue[0] : instance.state,
5443+ dontMutate = !0,
5444+ i = oldReplace ? 1 : 0;
5445+ i < oldQueue.length;
5446+ i++
5447+ ) {
5448+ var partial = oldQueue[i],
5449+ partialState$jscomp$0 =
5450+ "function" === typeof partial
5451+ ? partial.call(
5452+ instance,
5453+ nextState,
5454+ resolvedProps,
5455+ void 0
5456+ )
5457+ : partial;
5458+ null != partialState$jscomp$0 &&
5459+ (dontMutate
5460+ ? ((dontMutate = !1),
5461+ (nextState = assign(
5462+ {},
5463+ nextState,
5464+ partialState$jscomp$0
5465+ )))
5466+ : assign(nextState, partialState$jscomp$0));
5467+ }
5468+ instance.state = nextState;
5469+ }
5470+ } else internalInstance.queue = null;
5471+ }
5472+ var nextChildren = callRenderInDEV(instance);
5473+ if (12 === request.status) throw null;
5474+ instance.props !== resolvedProps &&
5475+ (didWarnAboutReassigningProps ||
5476+ console.error(
5477+ "It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.",
5478+ getComponentNameFromType(type) || "a component"
5479+ ),
5480+ (didWarnAboutReassigningProps = !0));
5481+ var prevKeyPath = task.keyPath;
5482+ task.keyPath = keyPath;
5483+ renderNodeDestructive(request, task, nextChildren, -1);
5484+ task.keyPath = prevKeyPath;
63935485 } else {
6394− // eslint-disable-next-line react-internal/safe-string-coercion
6395− _error = errorPrefix + String(_error);
5486+ if (type.prototype && "function" === typeof type.prototype.render) {
5487+ var componentName$jscomp$3 =
5488+ getComponentNameFromType(type) || "Unknown";
5489+ didWarnAboutBadClass[componentName$jscomp$3] ||
5490+ (console.error(
5491+ "The <%s /> component appears to have a render method, but doesn't extend React.Component. This is likely to cause errors. Change %s to extend React.Component instead.",
5492+ componentName$jscomp$3,
5493+ componentName$jscomp$3
5494+ ),
5495+ (didWarnAboutBadClass[componentName$jscomp$3] = !0));
5496+ }
5497+ var value = renderWithHooks(
5498+ request,
5499+ task,
5500+ keyPath,
5501+ type,
5502+ props,
5503+ void 0
5504+ );
5505+ if (12 === request.status) throw null;
5506+ var hasId = 0 !== localIdCounter,
5507+ actionStateCount = actionStateCounter,
5508+ actionStateMatchingIndex$jscomp$0 = actionStateMatchingIndex;
5509+ if (type.contextTypes) {
5510+ var _componentName$jscomp$0 =
5511+ getComponentNameFromType(type) || "Unknown";
5512+ didWarnAboutContextTypes[_componentName$jscomp$0] ||
5513+ ((didWarnAboutContextTypes[_componentName$jscomp$0] = !0),
5514+ console.error(
5515+ "%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with React.useContext() instead. (https://react.dev/link/legacy-context)",
5516+ _componentName$jscomp$0
5517+ ));
5518+ }
5519+ type &&
5520+ type.childContextTypes &&
5521+ console.error(
5522+ "childContextTypes cannot be defined on a function component.\n %s.childContextTypes = ...",
5523+ type.displayName || type.name || "Component"
5524+ );
5525+ if ("function" === typeof type.getDerivedStateFromProps) {
5526+ var componentName$jscomp$4 =
5527+ getComponentNameFromType(type) || "Unknown";
5528+ didWarnAboutGetDerivedStateOnFunctionComponent[
5529+ componentName$jscomp$4
5530+ ] ||
5531+ (console.error(
5532+ "%s: Function components do not support getDerivedStateFromProps.",
5533+ componentName$jscomp$4
5534+ ),
5535+ (didWarnAboutGetDerivedStateOnFunctionComponent[
5536+ componentName$jscomp$4
5537+ ] = !0));
5538+ }
5539+ if (
5540+ "object" === typeof type.contextType &&
5541+ null !== type.contextType
5542+ ) {
5543+ var _componentName2 = getComponentNameFromType(type) || "Unknown";
5544+ didWarnAboutContextTypeOnFunctionComponent[_componentName2] ||
5545+ (console.error(
5546+ "%s: Function components do not support contextType.",
5547+ _componentName2
5548+ ),
5549+ (didWarnAboutContextTypeOnFunctionComponent[_componentName2] =
5550+ !0));
5551+ }
5552+ finishFunctionComponent(
5553+ request,
5554+ task,
5555+ keyPath,
5556+ value,
5557+ hasId,
5558+ actionStateCount,
5559+ actionStateMatchingIndex$jscomp$0
5560+ );
63965561 }
6397−
6398− var previousTaskInDev = currentTaskInDEV;
6399− currentTaskInDEV = task;
6400−
6401− try {
6402− captureBoundaryErrorDetailsDev(boundary, _error);
6403− } finally {
6404− currentTaskInDEV = previousTaskInDev;
5562+ else if ("string" === typeof type) {
5563+ var segment = task.blockedSegment;
5564+ if (null === segment) {
5565+ var children = props.children,
5566+ prevContext = task.formatContext,
5567+ prevKeyPath$jscomp$0 = task.keyPath;
5568+ task.formatContext = getChildFormatContext(prevContext, type, props);
5569+ task.keyPath = keyPath;
5570+ renderNode(request, task, children, -1);
5571+ task.formatContext = prevContext;
5572+ task.keyPath = prevKeyPath$jscomp$0;
5573+ } else {
5574+ var _children = pushStartInstance(
5575+ segment.chunks,
5576+ type,
5577+ props,
5578+ request.resumableState,
5579+ request.renderState,
5580+ task.blockedPreamble,
5581+ task.hoistableState,
5582+ task.formatContext,
5583+ segment.lastPushedText
5584+ );
5585+ segment.lastPushedText = !1;
5586+ var _prevContext2 = task.formatContext,
5587+ _prevKeyPath3 = task.keyPath;
5588+ task.keyPath = keyPath;
5589+ if (
5590+ (task.formatContext = getChildFormatContext(
5591+ _prevContext2,
5592+ type,
5593+ props
5594+ )).insertionMode === HTML_HEAD_MODE
5595+ ) {
5596+ var preambleSegment = createPendingSegment(
5597+ request,
5598+ 0,
5599+ null,
5600+ task.formatContext,
5601+ !1,
5602+ !1
5603+ );
5604+ segment.preambleChildren.push(preambleSegment);
5605+ task.blockedSegment = preambleSegment;
5606+ try {
5607+ (preambleSegment.status = 6),
5608+ renderNode(request, task, _children, -1),
5609+ pushSegmentFinale(
5610+ preambleSegment.chunks,
5611+ request.renderState,
5612+ preambleSegment.lastPushedText,
5613+ preambleSegment.textEmbedded
5614+ ),
5615+ (preambleSegment.status = COMPLETED);
5616+ } finally {
5617+ task.blockedSegment = segment;
5618+ }
5619+ } else renderNode(request, task, _children, -1);
5620+ task.formatContext = _prevContext2;
5621+ task.keyPath = _prevKeyPath3;
5622+ a: {
5623+ var target = segment.chunks,
5624+ resumableState = request.resumableState;
5625+ switch (type) {
5626+ case "title":
5627+ case "style":
5628+ case "script":
5629+ case "area":
5630+ case "base":
5631+ case "br":
5632+ case "col":
5633+ case "embed":
5634+ case "hr":
5635+ case "img":
5636+ case "input":
5637+ case "keygen":
5638+ case "link":
5639+ case "meta":
5640+ case "param":
5641+ case "source":
5642+ case "track":
5643+ case "wbr":
5644+ break a;
5645+ case "body":
5646+ if (_prevContext2.insertionMode <= HTML_HTML_MODE) {
5647+ resumableState.hasBody = !0;
5648+ break a;
5649+ }
5650+ break;
5651+ case "html":
5652+ if (_prevContext2.insertionMode === ROOT_HTML_MODE) {
5653+ resumableState.hasHtml = !0;
5654+ break a;
5655+ }
5656+ break;
5657+ case "head":
5658+ if (_prevContext2.insertionMode <= HTML_HTML_MODE) break a;
5659+ }
5660+ target.push(endChunkForTag(type));
5661+ }
5662+ segment.lastPushedText = !1;
5663+ }
5664+ } else {
5665+ switch (type) {
5666+ case REACT_LEGACY_HIDDEN_TYPE:
5667+ case REACT_STRICT_MODE_TYPE:
5668+ case REACT_PROFILER_TYPE:
5669+ case REACT_FRAGMENT_TYPE:
5670+ var prevKeyPath$jscomp$1 = task.keyPath;
5671+ task.keyPath = keyPath;
5672+ renderNodeDestructive(request, task, props.children, -1);
5673+ task.keyPath = prevKeyPath$jscomp$1;
5674+ return;
5675+ case REACT_ACTIVITY_TYPE:
5676+ var segment$jscomp$0 = task.blockedSegment;
5677+ if (null === segment$jscomp$0) {
5678+ if ("hidden" !== props.mode) {
5679+ var prevKeyPath$jscomp$2 = task.keyPath;
5680+ task.keyPath = keyPath;
5681+ renderNode(request, task, props.children, -1);
5682+ task.keyPath = prevKeyPath$jscomp$2;
5683+ }
5684+ } else if ("hidden" !== props.mode) {
5685+ request.renderState.generateStaticMarkup ||
5686+ segment$jscomp$0.chunks.push("\x3c!--&--\x3e");
5687+ segment$jscomp$0.lastPushedText = !1;
5688+ var _prevKeyPath4 = task.keyPath;
5689+ task.keyPath = keyPath;
5690+ renderNode(request, task, props.children, -1);
5691+ task.keyPath = _prevKeyPath4;
5692+ request.renderState.generateStaticMarkup ||
5693+ segment$jscomp$0.chunks.push("\x3c!--/&--\x3e");
5694+ segment$jscomp$0.lastPushedText = !1;
5695+ }
5696+ return;
5697+ case REACT_SUSPENSE_LIST_TYPE:
5698+ a: {
5699+ var children$jscomp$0 = props.children,
5700+ revealOrder = props.revealOrder;
5701+ if (
5702+ "forwards" === revealOrder ||
5703+ "backwards" === revealOrder ||
5704+ "unstable_legacy-backwards" === revealOrder
5705+ ) {
5706+ if (isArrayImpl(children$jscomp$0)) {
5707+ renderSuspenseListRows(
5708+ request,
5709+ task,
5710+ keyPath,
5711+ children$jscomp$0,
5712+ revealOrder
5713+ );
5714+ break a;
5715+ }
5716+ var iteratorFn = getIteratorFn(children$jscomp$0);
5717+ if (iteratorFn) {
5718+ var iterator = iteratorFn.call(children$jscomp$0);
5719+ if (iterator) {
5720+ validateIterable(
5721+ task,
5722+ children$jscomp$0,
5723+ -1,
5724+ iterator,
5725+ iteratorFn
5726+ );
5727+ var step = iterator.next();
5728+ if (!step.done) {
5729+ var rows = [];
5730+ do rows.push(step.value), (step = iterator.next());
5731+ while (!step.done);
5732+ renderSuspenseListRows(
5733+ request,
5734+ task,
5735+ keyPath,
5736+ children$jscomp$0,
5737+ revealOrder
5738+ );
5739+ }
5740+ break a;
5741+ }
5742+ }
5743+ }
5744+ if ("together" === revealOrder) {
5745+ var _prevKeyPath2 = task.keyPath,
5746+ prevRow = task.row,
5747+ newRow = (task.row = createSuspenseListRow(null));
5748+ newRow.boundaries = [];
5749+ newRow.together = !0;
5750+ task.keyPath = keyPath;
5751+ renderNodeDestructive(request, task, children$jscomp$0, -1);
5752+ 0 === --newRow.pendingTasks &&
5753+ finishSuspenseListRow(request, newRow);
5754+ task.keyPath = _prevKeyPath2;
5755+ task.row = prevRow;
5756+ null !== prevRow &&
5757+ 0 < newRow.pendingTasks &&
5758+ (prevRow.pendingTasks++, (newRow.next = prevRow));
5759+ } else {
5760+ var prevKeyPath$jscomp$3 = task.keyPath;
5761+ task.keyPath = keyPath;
5762+ renderNodeDestructive(request, task, children$jscomp$0, -1);
5763+ task.keyPath = prevKeyPath$jscomp$3;
5764+ }
5765+ }
5766+ return;
5767+ case REACT_VIEW_TRANSITION_TYPE:
5768+ case REACT_SCOPE_TYPE:
5769+ throw Error(
5770+ "ReactDOMServer does not yet support scope components."
5771+ );
5772+ case REACT_SUSPENSE_TYPE:
5773+ a: if (null !== task.replay) {
5774+ var _prevKeyPath = task.keyPath,
5775+ _prevContext = task.formatContext,
5776+ _prevRow = task.row;
5777+ task.keyPath = keyPath;
5778+ task.formatContext = getSuspenseContentFormatContext(
5779+ request.resumableState,
5780+ _prevContext
5781+ );
5782+ task.row = null;
5783+ var _content = props.children;
5784+ try {
5785+ renderNode(request, task, _content, -1);
5786+ } finally {
5787+ (task.keyPath = _prevKeyPath),
5788+ (task.formatContext = _prevContext),
5789+ (task.row = _prevRow);
5790+ }
5791+ } else {
5792+ var prevKeyPath$jscomp$4 = task.keyPath,
5793+ prevContext$jscomp$0 = task.formatContext,
5794+ prevRow$jscomp$0 = task.row,
5795+ parentBoundary = task.blockedBoundary,
5796+ parentPreamble = task.blockedPreamble,
5797+ parentHoistableState = task.hoistableState,
5798+ parentSegment = task.blockedSegment,
5799+ fallback = props.fallback,
5800+ content = props.children,
5801+ fallbackAbortSet = new Set();
5802+ var newBoundary = createSuspenseBoundary(
5803+ request,
5804+ task.row,
5805+ fallbackAbortSet,
5806+ null,
5807+ null
5808+ );
5809+ null !== request.trackedPostpones &&
5810+ (newBoundary.trackedContentKeyPath = keyPath);
5811+ var boundarySegment = createPendingSegment(
5812+ request,
5813+ parentSegment.chunks.length,
5814+ newBoundary,
5815+ task.formatContext,
5816+ !1,
5817+ !1
5818+ );
5819+ parentSegment.children.push(boundarySegment);
5820+ parentSegment.lastPushedText = !1;
5821+ var contentRootSegment = createPendingSegment(
5822+ request,
5823+ 0,
5824+ null,
5825+ task.formatContext,
5826+ !1,
5827+ !1
5828+ );
5829+ contentRootSegment.parentFlushed = !0;
5830+ if (null !== request.trackedPostpones) {
5831+ var suspenseComponentStack = task.componentStack,
5832+ fallbackKeyPath = [
5833+ keyPath[0],
5834+ "Suspense Fallback",
5835+ keyPath[2]
5836+ ],
5837+ fallbackReplayNode = [
5838+ fallbackKeyPath[1],
5839+ fallbackKeyPath[2],
5840+ [],
5841+ null
5842+ ];
5843+ request.trackedPostpones.workingMap.set(
5844+ fallbackKeyPath,
5845+ fallbackReplayNode
5846+ );
5847+ newBoundary.trackedFallbackNode = fallbackReplayNode;
5848+ task.blockedSegment = boundarySegment;
5849+ task.blockedPreamble = newBoundary.fallbackPreamble;
5850+ task.keyPath = fallbackKeyPath;
5851+ task.formatContext = getSuspenseFallbackFormatContext(
5852+ request.resumableState,
5853+ prevContext$jscomp$0
5854+ );
5855+ task.componentStack =
5856+ replaceSuspenseComponentStackWithSuspenseFallbackStack(
5857+ suspenseComponentStack
5858+ );
5859+ boundarySegment.status = 6;
5860+ try {
5861+ renderNode(request, task, fallback, -1),
5862+ pushSegmentFinale(
5863+ boundarySegment.chunks,
5864+ request.renderState,
5865+ boundarySegment.lastPushedText,
5866+ boundarySegment.textEmbedded
5867+ ),
5868+ (boundarySegment.status = COMPLETED);
5869+ } catch (thrownValue) {
5870+ throw (
5871+ ((boundarySegment.status =
5872+ 12 === request.status ? ABORTED : ERRORED),
5873+ thrownValue)
5874+ );
5875+ } finally {
5876+ (task.blockedSegment = parentSegment),
5877+ (task.blockedPreamble = parentPreamble),
5878+ (task.keyPath = prevKeyPath$jscomp$4),
5879+ (task.formatContext = prevContext$jscomp$0);
5880+ }
5881+ var suspendedPrimaryTask = createRenderTask(
5882+ request,
5883+ null,
5884+ content,
5885+ -1,
5886+ newBoundary,
5887+ contentRootSegment,
5888+ newBoundary.contentPreamble,
5889+ newBoundary.contentState,
5890+ task.abortSet,
5891+ keyPath,
5892+ getSuspenseContentFormatContext(
5893+ request.resumableState,
5894+ task.formatContext
5895+ ),
5896+ task.context,
5897+ task.treeContext,
5898+ null,
5899+ suspenseComponentStack,
5900+ emptyContextObject,
5901+ task.debugTask
5902+ );
5903+ pushComponentStack(suspendedPrimaryTask);
5904+ request.pingedTasks.push(suspendedPrimaryTask);
5905+ } else {
5906+ task.blockedBoundary = newBoundary;
5907+ task.blockedPreamble = newBoundary.contentPreamble;
5908+ task.hoistableState = newBoundary.contentState;
5909+ task.blockedSegment = contentRootSegment;
5910+ task.keyPath = keyPath;
5911+ task.formatContext = getSuspenseContentFormatContext(
5912+ request.resumableState,
5913+ prevContext$jscomp$0
5914+ );
5915+ task.row = null;
5916+ contentRootSegment.status = 6;
5917+ try {
5918+ if (
5919+ (renderNode(request, task, content, -1),
5920+ pushSegmentFinale(
5921+ contentRootSegment.chunks,
5922+ request.renderState,
5923+ contentRootSegment.lastPushedText,
5924+ contentRootSegment.textEmbedded
5925+ ),
5926+ (contentRootSegment.status = COMPLETED),
5927+ queueCompletedSegment(newBoundary, contentRootSegment),
5928+ 0 === newBoundary.pendingTasks &&
5929+ newBoundary.status === PENDING)
5930+ ) {
5931+ if (
5932+ ((newBoundary.status = COMPLETED),
5933+ !isEligibleForOutlining(request, newBoundary))
5934+ ) {
5935+ null !== prevRow$jscomp$0 &&
5936+ 0 === --prevRow$jscomp$0.pendingTasks &&
5937+ finishSuspenseListRow(request, prevRow$jscomp$0);
5938+ 0 === request.pendingRootTasks &&
5939+ task.blockedPreamble &&
5940+ preparePreamble(request);
5941+ break a;
5942+ }
5943+ } else
5944+ null !== prevRow$jscomp$0 &&
5945+ prevRow$jscomp$0.together &&
5946+ tryToResolveTogetherRow(request, prevRow$jscomp$0);
5947+ } catch (thrownValue$2) {
5948+ newBoundary.status = CLIENT_RENDERED;
5949+ if (12 === request.status) {
5950+ contentRootSegment.status = ABORTED;
5951+ var error = request.fatalError;
5952+ } else
5953+ (contentRootSegment.status = ERRORED),
5954+ (error = thrownValue$2);
5955+ var thrownInfo = getThrownInfo(task.componentStack);
5956+ var errorDigest = logRecoverableError(
5957+ request,
5958+ error,
5959+ thrownInfo,
5960+ task.debugTask
5961+ );
5962+ encodeErrorForBoundary(
5963+ newBoundary,
5964+ errorDigest,
5965+ error,
5966+ thrownInfo,
5967+ !1
5968+ );
5969+ untrackBoundary(request, newBoundary);
5970+ } finally {
5971+ (task.blockedBoundary = parentBoundary),
5972+ (task.blockedPreamble = parentPreamble),
5973+ (task.hoistableState = parentHoistableState),
5974+ (task.blockedSegment = parentSegment),
5975+ (task.keyPath = prevKeyPath$jscomp$4),
5976+ (task.formatContext = prevContext$jscomp$0),
5977+ (task.row = prevRow$jscomp$0);
5978+ }
5979+ var suspendedFallbackTask = createRenderTask(
5980+ request,
5981+ null,
5982+ fallback,
5983+ -1,
5984+ parentBoundary,
5985+ boundarySegment,
5986+ newBoundary.fallbackPreamble,
5987+ newBoundary.fallbackState,
5988+ fallbackAbortSet,
5989+ [keyPath[0], "Suspense Fallback", keyPath[2]],
5990+ getSuspenseFallbackFormatContext(
5991+ request.resumableState,
5992+ task.formatContext
5993+ ),
5994+ task.context,
5995+ task.treeContext,
5996+ task.row,
5997+ replaceSuspenseComponentStackWithSuspenseFallbackStack(
5998+ task.componentStack
5999+ ),
6000+ emptyContextObject,
6001+ task.debugTask
6002+ );
6003+ pushComponentStack(suspendedFallbackTask);
6004+ request.pingedTasks.push(suspendedFallbackTask);
6005+ }
6006+ }
6007+ return;
6008+ }
6009+ if ("object" === typeof type && null !== type)
6010+ switch (type.$$typeof) {
6011+ case REACT_FORWARD_REF_TYPE:
6012+ if ("ref" in props) {
6013+ var propsWithoutRef = {};
6014+ for (var key in props)
6015+ "ref" !== key && (propsWithoutRef[key] = props[key]);
6016+ } else propsWithoutRef = props;
6017+ var children$jscomp$1 = renderWithHooks(
6018+ request,
6019+ task,
6020+ keyPath,
6021+ type.render,
6022+ propsWithoutRef,
6023+ ref
6024+ );
6025+ finishFunctionComponent(
6026+ request,
6027+ task,
6028+ keyPath,
6029+ children$jscomp$1,
6030+ 0 !== localIdCounter,
6031+ actionStateCounter,
6032+ actionStateMatchingIndex
6033+ );
6034+ return;
6035+ case REACT_MEMO_TYPE:
6036+ renderElement(request, task, keyPath, type.type, props, ref);
6037+ return;
6038+ case REACT_CONTEXT_TYPE:
6039+ var value$jscomp$0 = props.value,
6040+ children$jscomp$2 = props.children;
6041+ var prevSnapshot = task.context;
6042+ var prevKeyPath$jscomp$5 = task.keyPath;
6043+ var prevValue = type._currentValue2;
6044+ type._currentValue2 = value$jscomp$0;
6045+ void 0 !== type._currentRenderer2 &&
6046+ null !== type._currentRenderer2 &&
6047+ type._currentRenderer2 !== rendererSigil &&
6048+ console.error(
6049+ "Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."
6050+ );
6051+ type._currentRenderer2 = rendererSigil;
6052+ var prevNode = currentActiveSnapshot,
6053+ newNode = {
6054+ parent: prevNode,
6055+ depth: null === prevNode ? 0 : prevNode.depth + 1,
6056+ context: type,
6057+ parentValue: prevValue,
6058+ value: value$jscomp$0
6059+ };
6060+ currentActiveSnapshot = newNode;
6061+ task.context = newNode;
6062+ task.keyPath = keyPath;
6063+ renderNodeDestructive(request, task, children$jscomp$2, -1);
6064+ var prevSnapshot$jscomp$0 = currentActiveSnapshot;
6065+ if (null === prevSnapshot$jscomp$0)
6066+ throw Error(
6067+ "Tried to pop a Context at the root of the app. This is a bug in React."
6068+ );
6069+ prevSnapshot$jscomp$0.context !== type &&
6070+ console.error(
6071+ "The parent context is not the expected context. This is probably a bug in React."
6072+ );
6073+ prevSnapshot$jscomp$0.context._currentValue2 =
6074+ prevSnapshot$jscomp$0.parentValue;
6075+ void 0 !== type._currentRenderer2 &&
6076+ null !== type._currentRenderer2 &&
6077+ type._currentRenderer2 !== rendererSigil &&
6078+ console.error(
6079+ "Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."
6080+ );
6081+ type._currentRenderer2 = rendererSigil;
6082+ var JSCompiler_inline_result$jscomp$0 = (currentActiveSnapshot =
6083+ prevSnapshot$jscomp$0.parent);
6084+ task.context = JSCompiler_inline_result$jscomp$0;
6085+ task.keyPath = prevKeyPath$jscomp$5;
6086+ prevSnapshot !== task.context &&
6087+ console.error(
6088+ "Popping the context provider did not return back to the original snapshot. This is a bug in React."
6089+ );
6090+ return;
6091+ case REACT_CONSUMER_TYPE:
6092+ var context$jscomp$0 = type._context,
6093+ render = props.children;
6094+ "function" !== typeof render &&
6095+ console.error(
6096+ "A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."
6097+ );
6098+ var newChildren = render(context$jscomp$0._currentValue2),
6099+ prevKeyPath$jscomp$6 = task.keyPath;
6100+ task.keyPath = keyPath;
6101+ renderNodeDestructive(request, task, newChildren, -1);
6102+ task.keyPath = prevKeyPath$jscomp$6;
6103+ return;
6104+ case REACT_LAZY_TYPE:
6105+ var Component = callLazyInitInDEV(type);
6106+ if (12 === request.status) throw null;
6107+ renderElement(request, task, keyPath, Component, props, ref);
6108+ return;
6109+ }
6110+ var info = "";
6111+ if (
6112+ void 0 === type ||
6113+ ("object" === typeof type &&
6114+ null !== type &&
6115+ 0 === Object.keys(type).length)
6116+ )
6117+ info +=
6118+ " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
6119+ throw Error(
6120+ "Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " +
6121+ ((null == type ? type : typeof type) + "." + info)
6122+ );
6123+ }
6124+ }
6125+ function resumeNode(request, task, segmentId, node, childIndex) {
6126+ var prevReplay = task.replay,
6127+ blockedBoundary = task.blockedBoundary,
6128+ resumedSegment = createPendingSegment(
6129+ request,
6130+ 0,
6131+ null,
6132+ task.formatContext,
6133+ !1,
6134+ !1
6135+ );
6136+ resumedSegment.id = segmentId;
6137+ resumedSegment.parentFlushed = !0;
6138+ try {
6139+ (task.replay = null),
6140+ (task.blockedSegment = resumedSegment),
6141+ renderNode(request, task, node, childIndex),
6142+ (resumedSegment.status = COMPLETED),
6143+ null === blockedBoundary
6144+ ? (request.completedRootSegment = resumedSegment)
6145+ : (queueCompletedSegment(blockedBoundary, resumedSegment),
6146+ blockedBoundary.parentFlushed &&
6147+ request.partialBoundaries.push(blockedBoundary));
6148+ } finally {
6149+ (task.replay = prevReplay), (task.blockedSegment = null);
6150+ }
6151+ }
6152+ function replayElement(
6153+ request,
6154+ task,
6155+ keyPath,
6156+ name,
6157+ keyOrIndex,
6158+ childIndex,
6159+ type,
6160+ props,
6161+ ref,
6162+ replay
6163+ ) {
6164+ childIndex = replay.nodes;
6165+ for (var i = 0; i < childIndex.length; i++) {
6166+ var node = childIndex[i];
6167+ if (keyOrIndex === node[1]) {
6168+ if (4 === node.length) {
6169+ if (null !== name && name !== node[0])
6170+ throw Error(
6171+ "Expected the resume to render <" +
6172+ node[0] +
6173+ "> in this slot but instead it rendered <" +
6174+ name +
6175+ ">. The tree doesn't match so React will fallback to client rendering."
6176+ );
6177+ var childNodes = node[2];
6178+ name = node[3];
6179+ keyOrIndex = task.node;
6180+ task.replay = { nodes: childNodes, slots: name, pendingTasks: 1 };
6181+ try {
6182+ renderElement(request, task, keyPath, type, props, ref);
6183+ if (
6184+ 1 === task.replay.pendingTasks &&
6185+ 0 < task.replay.nodes.length
6186+ )
6187+ throw Error(
6188+ "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
6189+ );
6190+ task.replay.pendingTasks--;
6191+ } catch (x) {
6192+ if (
6193+ "object" === typeof x &&
6194+ null !== x &&
6195+ (x === SuspenseException || "function" === typeof x.then)
6196+ )
6197+ throw (
6198+ (task.node === keyOrIndex
6199+ ? (task.replay = replay)
6200+ : childIndex.splice(i, 1),
6201+ x)
6202+ );
6203+ task.replay.pendingTasks--;
6204+ type = getThrownInfo(task.componentStack);
6205+ props = request;
6206+ request = task.blockedBoundary;
6207+ keyPath = x;
6208+ ref = name;
6209+ name = logRecoverableError(props, keyPath, type, task.debugTask);
6210+ abortRemainingReplayNodes(
6211+ props,
6212+ request,
6213+ childNodes,
6214+ ref,
6215+ keyPath,
6216+ name,
6217+ type,
6218+ !1
6219+ );
6220+ }
6221+ task.replay = replay;
6222+ } else {
6223+ if (type !== REACT_SUSPENSE_TYPE)
6224+ throw Error(
6225+ "Expected the resume to render <Suspense> in this slot but instead it rendered <" +
6226+ (getComponentNameFromType(type) || "Unknown") +
6227+ ">. The tree doesn't match so React will fallback to client rendering."
6228+ );
6229+ a: {
6230+ replay = void 0;
6231+ name = node[5];
6232+ type = node[2];
6233+ ref = node[3];
6234+ keyOrIndex = null === node[4] ? [] : node[4][2];
6235+ node = null === node[4] ? null : node[4][3];
6236+ var prevKeyPath = task.keyPath,
6237+ prevContext = task.formatContext,
6238+ prevRow = task.row,
6239+ previousReplaySet = task.replay,
6240+ parentBoundary = task.blockedBoundary,
6241+ parentHoistableState = task.hoistableState,
6242+ content = props.children,
6243+ fallback = props.fallback,
6244+ fallbackAbortSet = new Set();
6245+ props = createSuspenseBoundary(
6246+ request,
6247+ task.row,
6248+ fallbackAbortSet,
6249+ null,
6250+ null
6251+ );
6252+ props.parentFlushed = !0;
6253+ props.rootSegmentID = name;
6254+ task.blockedBoundary = props;
6255+ task.hoistableState = props.contentState;
6256+ task.keyPath = keyPath;
6257+ task.formatContext = getSuspenseContentFormatContext(
6258+ request.resumableState,
6259+ prevContext
6260+ );
6261+ task.row = null;
6262+ task.replay = { nodes: type, slots: ref, pendingTasks: 1 };
6263+ try {
6264+ renderNode(request, task, content, -1);
6265+ if (
6266+ 1 === task.replay.pendingTasks &&
6267+ 0 < task.replay.nodes.length
6268+ )
6269+ throw Error(
6270+ "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
6271+ );
6272+ task.replay.pendingTasks--;
6273+ if (0 === props.pendingTasks && props.status === PENDING) {
6274+ props.status = COMPLETED;
6275+ request.completedBoundaries.push(props);
6276+ break a;
6277+ }
6278+ } catch (error) {
6279+ (props.status = CLIENT_RENDERED),
6280+ (childNodes = getThrownInfo(task.componentStack)),
6281+ (replay = logRecoverableError(
6282+ request,
6283+ error,
6284+ childNodes,
6285+ task.debugTask
6286+ )),
6287+ encodeErrorForBoundary(props, replay, error, childNodes, !1),
6288+ task.replay.pendingTasks--,
6289+ request.clientRenderedBoundaries.push(props);
6290+ } finally {
6291+ (task.blockedBoundary = parentBoundary),
6292+ (task.hoistableState = parentHoistableState),
6293+ (task.replay = previousReplaySet),
6294+ (task.keyPath = prevKeyPath),
6295+ (task.formatContext = prevContext),
6296+ (task.row = prevRow);
6297+ }
6298+ props = createReplayTask(
6299+ request,
6300+ null,
6301+ { nodes: keyOrIndex, slots: node, pendingTasks: 0 },
6302+ fallback,
6303+ -1,
6304+ parentBoundary,
6305+ props.fallbackState,
6306+ fallbackAbortSet,
6307+ [keyPath[0], "Suspense Fallback", keyPath[2]],
6308+ getSuspenseFallbackFormatContext(
6309+ request.resumableState,
6310+ task.formatContext
6311+ ),
6312+ task.context,
6313+ task.treeContext,
6314+ task.row,
6315+ replaceSuspenseComponentStackWithSuspenseFallbackStack(
6316+ task.componentStack
6317+ ),
6318+ emptyContextObject,
6319+ task.debugTask
6320+ );
6321+ pushComponentStack(props);
6322+ request.pingedTasks.push(props);
6323+ }
6324+ }
6325+ childIndex.splice(i, 1);
6326+ break;
64056327 }
64066328 }
6407−
6408− if (boundary.parentFlushed) {
6409− request.clientRenderedBoundaries.push(boundary);
6410− }
6411− } // If this boundary was still pending then we haven't already cancelled its fallbacks.
6412− // We'll need to abort the fallbacks, which will also error that parent boundary.
6413−
6414−
6415− boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
6416− return abortTask(fallbackTask, request, reason);
6417− });
6418− boundary.fallbackAbortableTasks.clear();
6419− request.allPendingTasks--;
6420−
6421− if (request.allPendingTasks === 0) {
6422− var onAllReady = request.onAllReady;
6423− onAllReady();
6424− }
6425− }
6426−}
6427−
6428−function queueCompletedSegment(boundary, segment) {
6429− if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
6430− // This is an empty segment. There's nothing to write, so we can instead transfer the ID
6431− // to the child. That way any existing references point to the child.
6432− var childSegment = segment.children[0];
6433− childSegment.id = segment.id;
6434− childSegment.parentFlushed = true;
6435−
6436− if (childSegment.status === COMPLETED) {
6437− queueCompletedSegment(boundary, childSegment);
6438− }
6439− } else {
6440− var completedSegments = boundary.completedSegments;
6441− completedSegments.push(segment);
6442− }
6443−}
6444−
6445−function finishedTask(request, boundary, segment) {
6446− if (boundary === null) {
6447− if (segment.parentFlushed) {
6448− if (request.completedRootSegment !== null) {
6449− throw new Error('There can only be one root segment. This is a bug in React.');
6450− }
6451−
6452− request.completedRootSegment = segment;
64536329 }
6454−
6455− request.pendingRootTasks--;
6456−
6457− if (request.pendingRootTasks === 0) {
6458− // We have completed the shell so the shell can't error anymore.
6459− request.onShellError = noop$1;
6460− var onShellReady = request.onShellReady;
6461− onShellReady();
6462− }
6463− } else {
6464− boundary.pendingTasks--;
6465−
6466− if (boundary.forceClientRender) ; else if (boundary.pendingTasks === 0) {
6467− // This must have been the last segment we were waiting on. This boundary is now complete.
6468− if (segment.parentFlushed) {
6469− // Our parent segment already flushed, so we need to schedule this segment to be emitted.
6470− // If it is a segment that was aborted, we'll write other content instead so we don't need
6471− // to emit it.
6472− if (segment.status === COMPLETED) {
6473− queueCompletedSegment(boundary, segment);
6330+ function validateIterable(
6331+ task,
6332+ iterable,
6333+ childIndex,
6334+ iterator,
6335+ iteratorFn
6336+ ) {
6337+ if (iterator === iterable) {
6338+ if (
6339+ -1 !== childIndex ||
6340+ null === task.componentStack ||
6341+ "function" !== typeof task.componentStack.type ||
6342+ "[object GeneratorFunction]" !==
6343+ Object.prototype.toString.call(task.componentStack.type) ||
6344+ "[object Generator]" !== Object.prototype.toString.call(iterator)
6345+ )
6346+ didWarnAboutGenerators ||
6347+ console.error(
6348+ "Using Iterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. You can also use an Iterable that can iterate multiple times over the same items."
6349+ ),
6350+ (didWarnAboutGenerators = !0);
6351+ } else
6352+ iterable.entries !== iteratorFn ||
6353+ didWarnAboutMaps ||
6354+ (console.error(
6355+ "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
6356+ ),
6357+ (didWarnAboutMaps = !0));
6358+ }
6359+ function renderNodeDestructive(request, task, node, childIndex) {
6360+ null !== task.replay && "number" === typeof task.replay.slots
6361+ ? resumeNode(request, task, task.replay.slots, node, childIndex)
6362+ : ((task.node = node),
6363+ (task.childIndex = childIndex),
6364+ (node = task.componentStack),
6365+ (childIndex = task.debugTask),
6366+ pushComponentStack(task),
6367+ retryNode(request, task),
6368+ (task.componentStack = node),
6369+ (task.debugTask = childIndex));
6370+ }
6371+ function retryNode(request, task) {
6372+ var node = task.node,
6373+ childIndex = task.childIndex;
6374+ if (null !== node) {
6375+ if ("object" === typeof node) {
6376+ switch (node.$$typeof) {
6377+ case REACT_ELEMENT_TYPE:
6378+ var type = node.type,
6379+ key = node.key;
6380+ node = node.props;
6381+ var refProp = node.ref;
6382+ refProp = void 0 !== refProp ? refProp : null;
6383+ var debugTask = task.debugTask,
6384+ name = getComponentNameFromType(type);
6385+ key = null == key ? (-1 === childIndex ? 0 : childIndex) : key;
6386+ var keyPath = [task.keyPath, name, key];
6387+ null !== task.replay
6388+ ? debugTask
6389+ ? debugTask.run(
6390+ replayElement.bind(
6391+ null,
6392+ request,
6393+ task,
6394+ keyPath,
6395+ name,
6396+ key,
6397+ childIndex,
6398+ type,
6399+ node,
6400+ refProp,
6401+ task.replay
6402+ )
6403+ )
6404+ : replayElement(
6405+ request,
6406+ task,
6407+ keyPath,
6408+ name,
6409+ key,
6410+ childIndex,
6411+ type,
6412+ node,
6413+ refProp,
6414+ task.replay
6415+ )
6416+ : debugTask
6417+ ? debugTask.run(
6418+ renderElement.bind(
6419+ null,
6420+ request,
6421+ task,
6422+ keyPath,
6423+ type,
6424+ node,
6425+ refProp
6426+ )
6427+ )
6428+ : renderElement(request, task, keyPath, type, node, refProp);
6429+ return;
6430+ case REACT_PORTAL_TYPE:
6431+ throw Error(
6432+ "Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render."
6433+ );
6434+ case REACT_LAZY_TYPE:
6435+ type = callLazyInitInDEV(node);
6436+ if (12 === request.status) throw null;
6437+ renderNodeDestructive(request, task, type, childIndex);
6438+ return;
6439+ }
6440+ if (isArrayImpl(node)) {
6441+ renderChildrenArray(request, task, node, childIndex);
6442+ return;
6443+ }
6444+ if ((key = getIteratorFn(node)))
6445+ if ((type = key.call(node))) {
6446+ validateIterable(task, node, childIndex, type, key);
6447+ node = type.next();
6448+ if (!node.done) {
6449+ key = [];
6450+ do key.push(node.value), (node = type.next());
6451+ while (!node.done);
6452+ renderChildrenArray(request, task, key, childIndex);
6453+ }
6454+ return;
6455+ }
6456+ if ("function" === typeof node.then)
6457+ return (
6458+ (task.thenableState = null),
6459+ renderNodeDestructive(
6460+ request,
6461+ task,
6462+ unwrapThenable(node),
6463+ childIndex
6464+ )
6465+ );
6466+ if (node.$$typeof === REACT_CONTEXT_TYPE)
6467+ return renderNodeDestructive(
6468+ request,
6469+ task,
6470+ node._currentValue2,
6471+ childIndex
6472+ );
6473+ request = Object.prototype.toString.call(node);
6474+ throw Error(
6475+ "Objects are not valid as a React child (found: " +
6476+ ("[object Object]" === request
6477+ ? "object with keys {" + Object.keys(node).join(", ") + "}"
6478+ : request) +
6479+ "). If you meant to render a collection of children, use an array instead."
6480+ );
6481+ }
6482+ "string" === typeof node
6483+ ? ((task = task.blockedSegment),
6484+ null !== task &&
6485+ (task.lastPushedText = pushTextInstance(
6486+ task.chunks,
6487+ node,
6488+ request.renderState,
6489+ task.lastPushedText
6490+ )))
6491+ : "number" === typeof node || "bigint" === typeof node
6492+ ? ((task = task.blockedSegment),
6493+ null !== task &&
6494+ (task.lastPushedText = pushTextInstance(
6495+ task.chunks,
6496+ "" + node,
6497+ request.renderState,
6498+ task.lastPushedText
6499+ )))
6500+ : ("function" === typeof node &&
6501+ ((request = node.displayName || node.name || "Component"),
6502+ console.error(
6503+ "Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.",
6504+ request,
6505+ request
6506+ )),
6507+ "symbol" === typeof node &&
6508+ console.error(
6509+ "Symbols are not valid as a React child.\n %s",
6510+ String(node)
6511+ ));
6512+ }
6513+ }
6514+ function warnForMissingKey(request, task, child) {
6515+ if (
6516+ null !== child &&
6517+ "object" === typeof child &&
6518+ (child.$$typeof === REACT_ELEMENT_TYPE ||
6519+ child.$$typeof === REACT_PORTAL_TYPE) &&
6520+ child._store &&
6521+ ((!child._store.validated && null == child.key) ||
6522+ 2 === child._store.validated)
6523+ ) {
6524+ if ("object" !== typeof child._store)
6525+ throw Error(
6526+ "React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."
6527+ );
6528+ child._store.validated = 1;
6529+ var didWarnForKey = request.didWarnForKey;
6530+ null == didWarnForKey &&
6531+ (didWarnForKey = request.didWarnForKey = new WeakSet());
6532+ request = task.componentStack;
6533+ if (null !== request && !didWarnForKey.has(request)) {
6534+ didWarnForKey.add(request);
6535+ var componentName = getComponentNameFromType(child.type);
6536+ didWarnForKey = child._owner;
6537+ var parentOwner = request.owner;
6538+ request = "";
6539+ if (parentOwner && "undefined" !== typeof parentOwner.type) {
6540+ var name = getComponentNameFromType(parentOwner.type);
6541+ name &&
6542+ (request = "\n\nCheck the render method of `" + name + "`.");
6543+ }
6544+ request ||
6545+ (componentName &&
6546+ (request =
6547+ "\n\nCheck the top-level render call using <" +
6548+ componentName +
6549+ ">."));
6550+ componentName = "";
6551+ null != didWarnForKey &&
6552+ parentOwner !== didWarnForKey &&
6553+ ((parentOwner = null),
6554+ "undefined" !== typeof didWarnForKey.type
6555+ ? (parentOwner = getComponentNameFromType(didWarnForKey.type))
6556+ : "string" === typeof didWarnForKey.name &&
6557+ (parentOwner = didWarnForKey.name),
6558+ parentOwner &&
6559+ (componentName =
6560+ " It was passed a child from " + parentOwner + "."));
6561+ didWarnForKey = task.componentStack;
6562+ task.componentStack = {
6563+ parent: task.componentStack,
6564+ type: child.type,
6565+ owner: child._owner,
6566+ stack: child._debugStack
6567+ };
6568+ console.error(
6569+ 'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
6570+ request,
6571+ componentName
6572+ );
6573+ task.componentStack = didWarnForKey;
64746574 }
64756575 }
6476−
6477− if (boundary.parentFlushed) {
6478− // The segment might be part of a segment that didn't flush yet, but if the boundary's
6479− // parent flushed, we need to schedule the boundary to be emitted.
6480− request.completedBoundaries.push(boundary);
6481− } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
6482− // This needs to happen after we read the parentFlushed flags because aborting can finish
6483− // work which can trigger user code, which can start flushing, which can change those flags.
6484−
6485−
6486− boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
6487− boundary.fallbackAbortableTasks.clear();
6488− } else {
6489− if (segment.parentFlushed) {
6490− // Our parent already flushed, so we need to schedule this segment to be emitted.
6491− // If it is a segment that was aborted, we'll write other content instead so we don't need
6492− // to emit it.
6493− if (segment.status === COMPLETED) {
6494− queueCompletedSegment(boundary, segment);
6495− var completedSegments = boundary.completedSegments;
6496−
6497− if (completedSegments.length === 1) {
6498− // This is the first time since we last flushed that we completed anything.
6499− // We can schedule this boundary to emit its partially completed segments early
6500− // in case the parent has already been flushed.
6501− if (boundary.parentFlushed) {
6502− request.partialBoundaries.push(boundary);
6576+ }
6577+ function renderChildrenArray(request, task, children, childIndex) {
6578+ var prevKeyPath = task.keyPath,
6579+ previousComponentStack = task.componentStack;
6580+ var previousDebugTask = task.debugTask;
6581+ pushServerComponentStack(task, task.node._debugInfo);
6582+ if (
6583+ -1 !== childIndex &&
6584+ ((task.keyPath = [task.keyPath, "Fragment", childIndex]),
6585+ null !== task.replay)
6586+ ) {
6587+ for (
6588+ var replay = task.replay, replayNodes = replay.nodes, j = 0;
6589+ j < replayNodes.length;
6590+ j++
6591+ ) {
6592+ var node = replayNodes[j];
6593+ if (node[1] === childIndex) {
6594+ childIndex = node[2];
6595+ node = node[3];
6596+ task.replay = { nodes: childIndex, slots: node, pendingTasks: 1 };
6597+ try {
6598+ renderChildrenArray(request, task, children, -1);
6599+ if (
6600+ 1 === task.replay.pendingTasks &&
6601+ 0 < task.replay.nodes.length
6602+ )
6603+ throw Error(
6604+ "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
6605+ );
6606+ task.replay.pendingTasks--;
6607+ } catch (x) {
6608+ if (
6609+ "object" === typeof x &&
6610+ null !== x &&
6611+ (x === SuspenseException || "function" === typeof x.then)
6612+ )
6613+ throw x;
6614+ task.replay.pendingTasks--;
6615+ var thrownInfo = getThrownInfo(task.componentStack);
6616+ children = task.blockedBoundary;
6617+ var error = x,
6618+ resumeSlots = node;
6619+ node = logRecoverableError(
6620+ request,
6621+ error,
6622+ thrownInfo,
6623+ task.debugTask
6624+ );
6625+ abortRemainingReplayNodes(
6626+ request,
6627+ children,
6628+ childIndex,
6629+ resumeSlots,
6630+ error,
6631+ node,
6632+ thrownInfo,
6633+ !1
6634+ );
65036635 }
6636+ task.replay = replay;
6637+ replayNodes.splice(j, 1);
6638+ break;
65046639 }
65056640 }
6641+ task.keyPath = prevKeyPath;
6642+ task.componentStack = previousComponentStack;
6643+ task.debugTask = previousDebugTask;
6644+ return;
65066645 }
6507− }
6508− }
6509−
6510− request.allPendingTasks--;
6511−
6512− if (request.allPendingTasks === 0) {
6513− // This needs to be called at the very end so that we can synchronously write the result
6514− // in the callback if needed.
6515− var onAllReady = request.onAllReady;
6516− onAllReady();
6517− }
6518−}
6519−
6520−function retryTask(request, task) {
6521− var segment = task.blockedSegment;
6522−
6523− if (segment.status !== PENDING) {
6524− // We completed this by other means before we had a chance to retry it.
6525− return;
6526− } // We restore the context to what it was when we suspended.
6527− // We don't restore it after we leave because it's likely that we'll end up
6528− // needing a very similar context soon again.
6529−
6530−
6531− switchContext(task.context);
6532− var prevTaskInDEV = null;
6533−
6534− {
6535− prevTaskInDEV = currentTaskInDEV;
6536− currentTaskInDEV = task;
6537− }
6538−
6539− try {
6540− // We call the destructive form that mutates this task. That way if something
6541− // suspends again, we can reuse the same task instead of spawning a new one.
6542− renderNodeDestructive(request, task, task.node);
6543− pushSegmentFinale$1(segment.chunks, request.responseState, segment.lastPushedText, segment.textEmbedded);
6544− task.abortSet.delete(task);
6545− segment.status = COMPLETED;
6546− finishedTask(request, task.blockedBoundary, segment);
6547− } catch (x) {
6548− resetHooksState();
6549−
6550− if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
6551− // Something suspended again, let's pick it back up later.
6552− var ping = task.ping;
6553− x.then(ping, ping);
6554− } else {
6555− task.abortSet.delete(task);
6556− segment.status = ERRORED;
6557− erroredTask(request, task.blockedBoundary, segment, x);
6558− }
6559− } finally {
6560− {
6561− currentTaskInDEV = prevTaskInDEV;
6562− }
6563− }
6564−}
6565−
6566−function performWork(request) {
6567− if (request.status === CLOSED) {
6568− return;
6569− }
6570−
6571− var prevContext = getActiveContext();
6572− var prevDispatcher = ReactCurrentDispatcher$1.current;
6573− ReactCurrentDispatcher$1.current = Dispatcher;
6574− var prevGetCurrentStackImpl;
6575−
6576− {
6577− prevGetCurrentStackImpl = ReactDebugCurrentFrame$1.getCurrentStack;
6578− ReactDebugCurrentFrame$1.getCurrentStack = getCurrentStackInDEV;
6579− }
6580−
6581− var prevResponseState = currentResponseState;
6582− setCurrentResponseState(request.responseState);
6583−
6584− try {
6585− var pingedTasks = request.pingedTasks;
6586− var i;
6587−
6588− for (i = 0; i < pingedTasks.length; i++) {
6589− var task = pingedTasks[i];
6590− retryTask(request, task);
6591− }
6592−
6593− pingedTasks.splice(0, i);
6594−
6595− if (request.destination !== null) {
6596− flushCompletedQueues(request, request.destination);
6597− }
6598− } catch (error) {
6599− logRecoverableError(request, error);
6600− fatalError(request, error);
6601− } finally {
6602− setCurrentResponseState(prevResponseState);
6603− ReactCurrentDispatcher$1.current = prevDispatcher;
6604−
6605− {
6606− ReactDebugCurrentFrame$1.getCurrentStack = prevGetCurrentStackImpl;
6607− }
6608−
6609− if (prevDispatcher === Dispatcher) {
6610− // This means that we were in a reentrant work loop. This could happen
6611− // in a renderer that supports synchronous work like renderToString,
6612− // when it's called from within another renderer.
6613− // Normally we don't bother switching the contexts to their root/default
6614− // values when leaving because we'll likely need the same or similar
6615− // context again. However, when we're inside a synchronous loop like this
6616− // we'll to restore the context to what it was before returning.
6617− switchContext(prevContext);
6618− }
6619− }
6620−}
6621−
6622−function flushSubtree(request, destination, segment) {
6623− segment.parentFlushed = true;
6624−
6625− switch (segment.status) {
6626− case PENDING:
6627− {
6628− // We're emitting a placeholder for this segment to be filled in later.
6629− // Therefore we'll need to assign it an ID - to refer to it by.
6630− var segmentID = segment.id = request.nextSegmentId++; // When this segment finally completes it won't be embedded in text since it will flush separately
6631−
6632− segment.lastPushedText = false;
6633− segment.textEmbedded = false;
6634− return writePlaceholder(destination, request.responseState, segmentID);
6646+ replay = task.treeContext;
6647+ replayNodes = children.length;
6648+ if (
6649+ null !== task.replay &&
6650+ ((j = task.replay.slots), null !== j && "object" === typeof j)
6651+ ) {
6652+ for (childIndex = 0; childIndex < replayNodes; childIndex++)
6653+ (node = children[childIndex]),
6654+ (task.treeContext = pushTreeContext(
6655+ replay,
6656+ replayNodes,
6657+ childIndex
6658+ )),
6659+ (error = j[childIndex]),
6660+ "number" === typeof error
6661+ ? (resumeNode(request, task, error, node, childIndex),
6662+ delete j[childIndex])
6663+ : renderNode(request, task, node, childIndex);
6664+ task.treeContext = replay;
6665+ task.keyPath = prevKeyPath;
6666+ task.componentStack = previousComponentStack;
6667+ task.debugTask = previousDebugTask;
6668+ return;
66356669 }
6636−
6637− case COMPLETED:
6638− {
6639− segment.status = FLUSHED;
6640− var r = true;
6641− var chunks = segment.chunks;
6642− var chunkIdx = 0;
6643− var children = segment.children;
6644−
6645− for (var childIdx = 0; childIdx < children.length; childIdx++) {
6646− var nextChild = children[childIdx]; // Write all the chunks up until the next child.
6647−
6648− for (; chunkIdx < nextChild.index; chunkIdx++) {
6649− writeChunk(destination, chunks[chunkIdx]);
6670+ for (j = 0; j < replayNodes; j++)
6671+ (childIndex = children[j]),
6672+ warnForMissingKey(request, task, childIndex),
6673+ (task.treeContext = pushTreeContext(replay, replayNodes, j)),
6674+ renderNode(request, task, childIndex, j);
6675+ task.treeContext = replay;
6676+ task.keyPath = prevKeyPath;
6677+ task.componentStack = previousComponentStack;
6678+ task.debugTask = previousDebugTask;
6679+ }
6680+ function trackPostponedBoundary(request, trackedPostpones, boundary) {
6681+ boundary.status = POSTPONED;
6682+ boundary.rootSegmentID = request.nextSegmentId++;
6683+ request = boundary.trackedContentKeyPath;
6684+ if (null === request)
6685+ throw Error(
6686+ "It should not be possible to postpone at the root. This is a bug in React."
6687+ );
6688+ var fallbackReplayNode = boundary.trackedFallbackNode,
6689+ children = [],
6690+ boundaryNode = trackedPostpones.workingMap.get(request);
6691+ if (void 0 === boundaryNode)
6692+ return (
6693+ (boundary = [
6694+ request[1],
6695+ request[2],
6696+ children,
6697+ null,
6698+ fallbackReplayNode,
6699+ boundary.rootSegmentID
6700+ ]),
6701+ trackedPostpones.workingMap.set(request, boundary),
6702+ addToReplayParent(boundary, request[0], trackedPostpones),
6703+ boundary
6704+ );
6705+ boundaryNode[4] = fallbackReplayNode;
6706+ boundaryNode[5] = boundary.rootSegmentID;
6707+ return boundaryNode;
6708+ }
6709+ function trackPostpone(request, trackedPostpones, task, segment) {
6710+ segment.status = POSTPONED;
6711+ var keyPath = task.keyPath,
6712+ boundary = task.blockedBoundary;
6713+ if (null === boundary)
6714+ (segment.id = request.nextSegmentId++),
6715+ (trackedPostpones.rootSlots = segment.id),
6716+ null !== request.completedRootSegment &&
6717+ (request.completedRootSegment.status = POSTPONED);
6718+ else {
6719+ if (null !== boundary && boundary.status === PENDING) {
6720+ var boundaryNode = trackPostponedBoundary(
6721+ request,
6722+ trackedPostpones,
6723+ boundary
6724+ );
6725+ if (
6726+ boundary.trackedContentKeyPath === keyPath &&
6727+ -1 === task.childIndex
6728+ ) {
6729+ -1 === segment.id &&
6730+ (segment.id = segment.parentFlushed
6731+ ? boundary.rootSegmentID
6732+ : request.nextSegmentId++);
6733+ boundaryNode[3] = segment.id;
6734+ return;
66506735 }
6651−
6652− r = flushSegment(request, destination, nextChild);
6653− } // Finally just write all the remaining chunks
6654−
6655−
6656− for (; chunkIdx < chunks.length - 1; chunkIdx++) {
6657− writeChunk(destination, chunks[chunkIdx]);
66586736 }
6659−
6660− if (chunkIdx < chunks.length) {
6661− r = writeChunkAndReturn(destination, chunks[chunkIdx]);
6737+ -1 === segment.id &&
6738+ (segment.id =
6739+ segment.parentFlushed && null !== boundary
6740+ ? boundary.rootSegmentID
6741+ : request.nextSegmentId++);
6742+ if (-1 === task.childIndex)
6743+ null === keyPath
6744+ ? (trackedPostpones.rootSlots = segment.id)
6745+ : ((task = trackedPostpones.workingMap.get(keyPath)),
6746+ void 0 === task
6747+ ? ((task = [keyPath[1], keyPath[2], [], segment.id]),
6748+ addToReplayParent(task, keyPath[0], trackedPostpones))
6749+ : (task[3] = segment.id));
6750+ else {
6751+ if (null === keyPath)
6752+ if (((request = trackedPostpones.rootSlots), null === request))
6753+ request = trackedPostpones.rootSlots = {};
6754+ else {
6755+ if ("number" === typeof request)
6756+ throw Error(
6757+ "It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React."
6758+ );
6759+ }
6760+ else if (
6761+ ((boundary = trackedPostpones.workingMap),
6762+ (boundaryNode = boundary.get(keyPath)),
6763+ void 0 === boundaryNode)
6764+ )
6765+ (request = {}),
6766+ (boundaryNode = [keyPath[1], keyPath[2], [], request]),
6767+ boundary.set(keyPath, boundaryNode),
6768+ addToReplayParent(boundaryNode, keyPath[0], trackedPostpones);
6769+ else if (((request = boundaryNode[3]), null === request))
6770+ request = boundaryNode[3] = {};
6771+ else if ("number" === typeof request)
6772+ throw Error(
6773+ "It should not be possible to postpone both at the root of an element as well as a slot below. This is a bug in React."
6774+ );
6775+ request[task.childIndex] = segment.id;
66626776 }
6663−
6664− return r;
66656777 }
6666−
6667− default:
6668− {
6669− throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
6670− }
6671− }
6672−}
6673−
6674−function flushSegment(request, destination, segment) {
6675− var boundary = segment.boundary;
6676−
6677− if (boundary === null) {
6678− // Not a suspense boundary.
6679− return flushSubtree(request, destination, segment);
6680− }
6681−
6682− boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
6683− // emit the content or the fallback now.
6684−
6685− if (boundary.forceClientRender) {
6686− // Emit a client rendered suspense boundary wrapper.
6687− // We never queue the inner boundary so we'll never emit its content or partial segments.
6688− writeStartClientRenderedSuspenseBoundary$1(destination, request.responseState, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack); // Flush the fallback.
6689−
6690− flushSubtree(request, destination, segment);
6691− return writeEndClientRenderedSuspenseBoundary$1(destination, request.responseState);
6692− } else if (boundary.pendingTasks > 0) {
6693− // This boundary is still loading. Emit a pending suspense boundary wrapper.
6694− // Assign an ID to refer to the future content by.
6695− boundary.rootSegmentID = request.nextSegmentId++;
6696−
6697− if (boundary.completedSegments.length > 0) {
6698− // If this is at least partially complete, we can queue it to be partially emitted early.
6699− request.partialBoundaries.push(boundary);
6700− } /// This is the first time we should have referenced this ID.
6701−
6702−
6703− var id = boundary.id = assignSuspenseBoundaryID(request.responseState);
6704− writeStartPendingSuspenseBoundary(destination, request.responseState, id); // Flush the fallback.
6705−
6706− flushSubtree(request, destination, segment);
6707− return writeEndPendingSuspenseBoundary(destination, request.responseState);
6708− } else if (boundary.byteSize > request.progressiveChunkSize) {
6709− // This boundary is large and will be emitted separately so that we can progressively show
6710− // other content. We add it to the queue during the flush because we have to ensure that
6711− // the parent flushes first so that there's something to inject it into.
6712− // We also have to make sure that it's emitted into the queue in a deterministic slot.
6713− // I.e. we can't insert it here when it completes.
6714− // Assign an ID to refer to the future content by.
6715− boundary.rootSegmentID = request.nextSegmentId++;
6716− request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
6717−
6718− writeStartPendingSuspenseBoundary(destination, request.responseState, boundary.id); // Flush the fallback.
6719−
6720− flushSubtree(request, destination, segment);
6721− return writeEndPendingSuspenseBoundary(destination, request.responseState);
6722− } else {
6723− // We can inline this boundary's content as a complete boundary.
6724− writeStartCompletedSuspenseBoundary$1(destination, request.responseState);
6725− var completedSegments = boundary.completedSegments;
6726−
6727− if (completedSegments.length !== 1) {
6728− throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
6729− }
6730−
6731− var contentSegment = completedSegments[0];
6732− flushSegment(request, destination, contentSegment);
6733− return writeEndCompletedSuspenseBoundary$1(destination, request.responseState);
6734− }
6735−}
6736−
6737−function flushClientRenderedBoundary(request, destination, boundary) {
6738− return writeClientRenderBoundaryInstruction(destination, request.responseState, boundary.id, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
6739−}
6740−
6741−function flushSegmentContainer(request, destination, segment) {
6742− writeStartSegment(destination, request.responseState, segment.formatContext, segment.id);
6743− flushSegment(request, destination, segment);
6744− return writeEndSegment(destination, segment.formatContext);
6745−}
6746−
6747−function flushCompletedBoundary(request, destination, boundary) {
6748− var completedSegments = boundary.completedSegments;
6749− var i = 0;
6750−
6751− for (; i < completedSegments.length; i++) {
6752− var segment = completedSegments[i];
6753− flushPartiallyCompletedSegment(request, destination, boundary, segment);
6754− }
6755−
6756− completedSegments.length = 0;
6757− return writeCompletedBoundaryInstruction(destination, request.responseState, boundary.id, boundary.rootSegmentID);
6758−}
6759−
6760−function flushPartialBoundary(request, destination, boundary) {
6761− var completedSegments = boundary.completedSegments;
6762− var i = 0;
6763−
6764− for (; i < completedSegments.length; i++) {
6765− var segment = completedSegments[i];
6766−
6767− if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
6768− i++;
6769− completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
6770− // might want to write later.
6771−
6772− return false;
6773− }
6774− }
6775−
6776− completedSegments.splice(0, i);
6777− return true;
6778−}
6779−
6780−function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
6781− if (segment.status === FLUSHED) {
6782− // We've already flushed this inline.
6783− return true;
6784− }
6785−
6786− var segmentID = segment.id;
6787−
6788− if (segmentID === -1) {
6789− // This segment wasn't previously referred to. This happens at the root of
6790− // a boundary. We make kind of a leap here and assume this is the root.
6791− var rootSegmentID = segment.id = boundary.rootSegmentID;
6792−
6793− if (rootSegmentID === -1) {
6794− throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
67956778 }
6796−
6797− return flushSegmentContainer(request, destination, segment);
6798− } else {
6799− flushSegmentContainer(request, destination, segment);
6800− return writeCompletedSegmentInstruction(destination, request.responseState, segmentID);
6801− }
6802−}
6803−
6804−function flushCompletedQueues(request, destination) {
6805−
6806− try {
6807− // The structure of this is to go through each queue one by one and write
6808− // until the sink tells us to stop. When we should stop, we still finish writing
6809− // that item fully and then yield. At that point we remove the already completed
6810− // items up until the point we completed them.
6811− // TODO: Emit preloading.
6812− // TODO: It's kind of unfortunate to keep checking this array after we've already
6813− // emitted the root.
6814− var completedRootSegment = request.completedRootSegment;
6815−
6816− if (completedRootSegment !== null && request.pendingRootTasks === 0) {
6817− flushSegment(request, destination, completedRootSegment);
6818− request.completedRootSegment = null;
6819− writeCompletedRoot(destination, request.responseState);
6820− } // We emit client rendering instructions for already emitted boundaries first.
6821− // This is so that we can signal to the client to start client rendering them as
6822− // soon as possible.
6823−
6824−
6825− var clientRenderedBoundaries = request.clientRenderedBoundaries;
6826− var i;
6827−
6828− for (i = 0; i < clientRenderedBoundaries.length; i++) {
6829− var boundary = clientRenderedBoundaries[i];
6830−
6831− if (!flushClientRenderedBoundary(request, destination, boundary)) {
6832− request.destination = null;
6833− i++;
6834− clientRenderedBoundaries.splice(0, i);
6835− return;
6779+ function untrackBoundary(request, boundary) {
6780+ request = request.trackedPostpones;
6781+ null !== request &&
6782+ ((boundary = boundary.trackedContentKeyPath),
6783+ null !== boundary &&
6784+ ((boundary = request.workingMap.get(boundary)),
6785+ void 0 !== boundary &&
6786+ ((boundary.length = 4), (boundary[2] = []), (boundary[3] = null))));
6787+ }
6788+ function spawnNewSuspendedReplayTask(request, task, thenableState) {
6789+ return createReplayTask(
6790+ request,
6791+ thenableState,
6792+ task.replay,
6793+ task.node,
6794+ task.childIndex,
6795+ task.blockedBoundary,
6796+ task.hoistableState,
6797+ task.abortSet,
6798+ task.keyPath,
6799+ task.formatContext,
6800+ task.context,
6801+ task.treeContext,
6802+ task.row,
6803+ task.componentStack,
6804+ emptyContextObject,
6805+ task.debugTask
6806+ );
6807+ }
6808+ function spawnNewSuspendedRenderTask(request, task, thenableState) {
6809+ var segment = task.blockedSegment,
6810+ newSegment = createPendingSegment(
6811+ request,
6812+ segment.chunks.length,
6813+ null,
6814+ task.formatContext,
6815+ segment.lastPushedText,
6816+ !0
6817+ );
6818+ segment.children.push(newSegment);
6819+ segment.lastPushedText = !1;
6820+ return createRenderTask(
6821+ request,
6822+ thenableState,
6823+ task.node,
6824+ task.childIndex,
6825+ task.blockedBoundary,
6826+ newSegment,
6827+ task.blockedPreamble,
6828+ task.hoistableState,
6829+ task.abortSet,
6830+ task.keyPath,
6831+ task.formatContext,
6832+ task.context,
6833+ task.treeContext,
6834+ task.row,
6835+ task.componentStack,
6836+ emptyContextObject,
6837+ task.debugTask
6838+ );
6839+ }
6840+ function renderNode(request, task, node, childIndex) {
6841+ var previousFormatContext = task.formatContext,
6842+ previousContext = task.context,
6843+ previousKeyPath = task.keyPath,
6844+ previousTreeContext = task.treeContext,
6845+ previousComponentStack = task.componentStack,
6846+ previousDebugTask = task.debugTask,
6847+ segment = task.blockedSegment;
6848+ if (null === segment) {
6849+ segment = task.replay;
6850+ try {
6851+ return renderNodeDestructive(request, task, node, childIndex);
6852+ } catch (thrownValue) {
6853+ if (
6854+ (resetHooksState(),
6855+ (node =
6856+ thrownValue === SuspenseException
6857+ ? getSuspendedThenable()
6858+ : thrownValue),
6859+ 12 !== request.status && "object" === typeof node && null !== node)
6860+ ) {
6861+ if ("function" === typeof node.then) {
6862+ childIndex =
6863+ thrownValue === SuspenseException
6864+ ? getThenableStateAfterSuspending()
6865+ : null;
6866+ request = spawnNewSuspendedReplayTask(
6867+ request,
6868+ task,
6869+ childIndex
6870+ ).ping;
6871+ node.then(request, request);
6872+ task.formatContext = previousFormatContext;
6873+ task.context = previousContext;
6874+ task.keyPath = previousKeyPath;
6875+ task.treeContext = previousTreeContext;
6876+ task.componentStack = previousComponentStack;
6877+ task.replay = segment;
6878+ task.debugTask = previousDebugTask;
6879+ switchContext(previousContext);
6880+ return;
6881+ }
6882+ if ("Maximum call stack size exceeded" === node.message) {
6883+ node =
6884+ thrownValue === SuspenseException
6885+ ? getThenableStateAfterSuspending()
6886+ : null;
6887+ node = spawnNewSuspendedReplayTask(request, task, node);
6888+ request.pingedTasks.push(node);
6889+ task.formatContext = previousFormatContext;
6890+ task.context = previousContext;
6891+ task.keyPath = previousKeyPath;
6892+ task.treeContext = previousTreeContext;
6893+ task.componentStack = previousComponentStack;
6894+ task.replay = segment;
6895+ task.debugTask = previousDebugTask;
6896+ switchContext(previousContext);
6897+ return;
6898+ }
6899+ }
6900+ }
6901+ } else {
6902+ var childrenLength = segment.children.length,
6903+ chunkLength = segment.chunks.length;
6904+ try {
6905+ return renderNodeDestructive(request, task, node, childIndex);
6906+ } catch (thrownValue$3) {
6907+ if (
6908+ (resetHooksState(),
6909+ (segment.children.length = childrenLength),
6910+ (segment.chunks.length = chunkLength),
6911+ (node =
6912+ thrownValue$3 === SuspenseException
6913+ ? getSuspendedThenable()
6914+ : thrownValue$3),
6915+ 12 !== request.status && "object" === typeof node && null !== node)
6916+ ) {
6917+ if ("function" === typeof node.then) {
6918+ segment = node;
6919+ node =
6920+ thrownValue$3 === SuspenseException
6921+ ? getThenableStateAfterSuspending()
6922+ : null;
6923+ request = spawnNewSuspendedRenderTask(request, task, node).ping;
6924+ segment.then(request, request);
6925+ task.formatContext = previousFormatContext;
6926+ task.context = previousContext;
6927+ task.keyPath = previousKeyPath;
6928+ task.treeContext = previousTreeContext;
6929+ task.componentStack = previousComponentStack;
6930+ task.debugTask = previousDebugTask;
6931+ switchContext(previousContext);
6932+ return;
6933+ }
6934+ if ("Maximum call stack size exceeded" === node.message) {
6935+ segment =
6936+ thrownValue$3 === SuspenseException
6937+ ? getThenableStateAfterSuspending()
6938+ : null;
6939+ segment = spawnNewSuspendedRenderTask(request, task, segment);
6940+ request.pingedTasks.push(segment);
6941+ task.formatContext = previousFormatContext;
6942+ task.context = previousContext;
6943+ task.keyPath = previousKeyPath;
6944+ task.treeContext = previousTreeContext;
6945+ task.componentStack = previousComponentStack;
6946+ task.debugTask = previousDebugTask;
6947+ switchContext(previousContext);
6948+ return;
6949+ }
6950+ }
6951+ }
68366952 }
6837− }
6838−
6839− clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
6840− // that are completely done since we can actually show them, than it is to emit
6841− // any individual segments from a partially complete boundary.
6842−
6843− var completedBoundaries = request.completedBoundaries;
6844−
6845− for (i = 0; i < completedBoundaries.length; i++) {
6846− var _boundary = completedBoundaries[i];
6847−
6848− if (!flushCompletedBoundary(request, destination, _boundary)) {
6849− request.destination = null;
6850− i++;
6851− completedBoundaries.splice(0, i);
6852− return;
6953+ task.formatContext = previousFormatContext;
6954+ task.context = previousContext;
6955+ task.keyPath = previousKeyPath;
6956+ task.treeContext = previousTreeContext;
6957+ switchContext(previousContext);
6958+ throw node;
6959+ }
6960+ function abortTaskSoft(task) {
6961+ var boundary = task.blockedBoundary,
6962+ segment = task.blockedSegment;
6963+ null !== segment &&
6964+ ((segment.status = ABORTED),
6965+ finishedTask(this, boundary, task.row, segment));
6966+ }
6967+ function abortRemainingReplayNodes(
6968+ request$jscomp$0,
6969+ boundary,
6970+ nodes,
6971+ slots,
6972+ error$jscomp$0,
6973+ errorDigest$jscomp$0,
6974+ errorInfo$jscomp$0,
6975+ aborted
6976+ ) {
6977+ for (var i = 0; i < nodes.length; i++) {
6978+ var node = nodes[i];
6979+ if (4 === node.length)
6980+ abortRemainingReplayNodes(
6981+ request$jscomp$0,
6982+ boundary,
6983+ node[2],
6984+ node[3],
6985+ error$jscomp$0,
6986+ errorDigest$jscomp$0,
6987+ errorInfo$jscomp$0,
6988+ aborted
6989+ );
6990+ else {
6991+ var request = request$jscomp$0;
6992+ node = node[5];
6993+ var error = error$jscomp$0,
6994+ errorDigest = errorDigest$jscomp$0,
6995+ errorInfo = errorInfo$jscomp$0,
6996+ wasAborted = aborted,
6997+ resumedBoundary = createSuspenseBoundary(
6998+ request,
6999+ null,
7000+ new Set(),
7001+ null,
7002+ null
7003+ );
7004+ resumedBoundary.parentFlushed = !0;
7005+ resumedBoundary.rootSegmentID = node;
7006+ resumedBoundary.status = CLIENT_RENDERED;
7007+ encodeErrorForBoundary(
7008+ resumedBoundary,
7009+ errorDigest,
7010+ error,
7011+ errorInfo,
7012+ wasAborted
7013+ );
7014+ resumedBoundary.parentFlushed &&
7015+ request.clientRenderedBoundaries.push(resumedBoundary);
7016+ }
68537017 }
6854− }
6855−
6856− completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
6857− // we continue with lower priorities.
6858−
6859− completeWriting(destination);
6860− beginWriting(destination); // TODO: Here we'll emit data used by hydration.
6861− // Next we emit any segments of any boundaries that are partially complete
6862− // but not deeply complete.
6863−
6864− var partialBoundaries = request.partialBoundaries;
6865−
6866− for (i = 0; i < partialBoundaries.length; i++) {
6867− var _boundary2 = partialBoundaries[i];
6868−
6869− if (!flushPartialBoundary(request, destination, _boundary2)) {
6870− request.destination = null;
6871− i++;
6872− partialBoundaries.splice(0, i);
6873− return;
7018+ nodes.length = 0;
7019+ if (null !== slots) {
7020+ if (null === boundary)
7021+ throw Error(
7022+ "We should not have any resumable nodes in the shell. This is a bug in React."
7023+ );
7024+ boundary.status !== CLIENT_RENDERED &&
7025+ ((boundary.status = CLIENT_RENDERED),
7026+ encodeErrorForBoundary(
7027+ boundary,
7028+ errorDigest$jscomp$0,
7029+ error$jscomp$0,
7030+ errorInfo$jscomp$0,
7031+ aborted
7032+ ),
7033+ boundary.parentFlushed &&
7034+ request$jscomp$0.clientRenderedBoundaries.push(boundary));
7035+ if ("object" === typeof slots)
7036+ for (var index in slots) delete slots[index];
7037+ }
7038+ }
7039+ function abortTask(task, request, error) {
7040+ var boundary = task.blockedBoundary,
7041+ segment = task.blockedSegment;
7042+ if (null !== segment) {
7043+ if (6 === segment.status) return;
7044+ segment.status = ABORTED;
7045+ }
7046+ var errorInfo = getThrownInfo(task.componentStack),
7047+ node = task.node;
7048+ null !== node &&
7049+ "object" === typeof node &&
7050+ pushHaltedAwaitOnComponentStack(task, node._debugInfo);
7051+ if (null === boundary) {
7052+ if (13 !== request.status && request.status !== CLOSED) {
7053+ boundary = task.replay;
7054+ if (null === boundary) {
7055+ null !== request.trackedPostpones && null !== segment
7056+ ? ((boundary = request.trackedPostpones),
7057+ logRecoverableError(request, error, errorInfo, task.debugTask),
7058+ trackPostpone(request, boundary, task, segment),
7059+ finishedTask(request, null, task.row, segment))
7060+ : (logRecoverableError(request, error, errorInfo, task.debugTask),
7061+ fatalError(request, error, errorInfo, task.debugTask));
7062+ return;
7063+ }
7064+ boundary.pendingTasks--;
7065+ 0 === boundary.pendingTasks &&
7066+ 0 < boundary.nodes.length &&
7067+ ((segment = logRecoverableError(request, error, errorInfo, null)),
7068+ abortRemainingReplayNodes(
7069+ request,
7070+ null,
7071+ boundary.nodes,
7072+ boundary.slots,
7073+ error,
7074+ segment,
7075+ errorInfo,
7076+ !0
7077+ ));
7078+ request.pendingRootTasks--;
7079+ 0 === request.pendingRootTasks && completeShell(request);
7080+ }
7081+ } else {
7082+ node = request.trackedPostpones;
7083+ if (boundary.status !== CLIENT_RENDERED) {
7084+ if (null !== node && null !== segment)
7085+ return (
7086+ logRecoverableError(request, error, errorInfo, task.debugTask),
7087+ trackPostpone(request, node, task, segment),
7088+ boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
7089+ return abortTask(fallbackTask, request, error);
7090+ }),
7091+ boundary.fallbackAbortableTasks.clear(),
7092+ finishedTask(request, boundary, task.row, segment)
7093+ );
7094+ boundary.status = CLIENT_RENDERED;
7095+ segment = logRecoverableError(
7096+ request,
7097+ error,
7098+ errorInfo,
7099+ task.debugTask
7100+ );
7101+ boundary.status = CLIENT_RENDERED;
7102+ encodeErrorForBoundary(boundary, segment, error, errorInfo, !0);
7103+ untrackBoundary(request, boundary);
7104+ boundary.parentFlushed &&
7105+ request.clientRenderedBoundaries.push(boundary);
7106+ }
7107+ boundary.pendingTasks--;
7108+ errorInfo = boundary.row;
7109+ null !== errorInfo &&
7110+ 0 === --errorInfo.pendingTasks &&
7111+ finishSuspenseListRow(request, errorInfo);
7112+ boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
7113+ return abortTask(fallbackTask, request, error);
7114+ });
7115+ boundary.fallbackAbortableTasks.clear();
7116+ }
7117+ task = task.row;
7118+ null !== task &&
7119+ 0 === --task.pendingTasks &&
7120+ finishSuspenseListRow(request, task);
7121+ request.allPendingTasks--;
7122+ 0 === request.allPendingTasks && completeAll(request);
7123+ }
7124+ function safelyEmitEarlyPreloads(request, shellComplete) {
7125+ try {
7126+ var renderState = request.renderState,
7127+ onHeaders = renderState.onHeaders;
7128+ if (onHeaders) {
7129+ var headers = renderState.headers;
7130+ if (headers) {
7131+ renderState.headers = null;
7132+ var linkHeader = headers.preconnects;
7133+ headers.fontPreloads &&
7134+ (linkHeader && (linkHeader += ", "),
7135+ (linkHeader += headers.fontPreloads));
7136+ headers.highImagePreloads &&
7137+ (linkHeader && (linkHeader += ", "),
7138+ (linkHeader += headers.highImagePreloads));
7139+ if (!shellComplete) {
7140+ var queueIter = renderState.styles.values(),
7141+ queueStep = queueIter.next();
7142+ b: for (
7143+ ;
7144+ 0 < headers.remainingCapacity && !queueStep.done;
7145+ queueStep = queueIter.next()
7146+ )
7147+ for (
7148+ var sheetIter = queueStep.value.sheets.values(),
7149+ sheetStep = sheetIter.next();
7150+ 0 < headers.remainingCapacity && !sheetStep.done;
7151+ sheetStep = sheetIter.next()
7152+ ) {
7153+ var sheet = sheetStep.value,
7154+ props = sheet.props,
7155+ key = props.href,
7156+ props$jscomp$0 = sheet.props;
7157+ var header = getPreloadAsHeader(
7158+ props$jscomp$0.href,
7159+ "style",
7160+ {
7161+ crossOrigin: props$jscomp$0.crossOrigin,
7162+ integrity: props$jscomp$0.integrity,
7163+ nonce: props$jscomp$0.nonce,
7164+ type: props$jscomp$0.type,
7165+ fetchPriority: props$jscomp$0.fetchPriority,
7166+ referrerPolicy: props$jscomp$0.referrerPolicy,
7167+ media: props$jscomp$0.media
7168+ }
7169+ );
7170+ if (0 <= (headers.remainingCapacity -= header.length + 2))
7171+ (renderState.resets.style[key] = PRELOAD_NO_CREDS),
7172+ linkHeader && (linkHeader += ", "),
7173+ (linkHeader += header),
7174+ (renderState.resets.style[key] =
7175+ "string" === typeof props.crossOrigin ||
7176+ "string" === typeof props.integrity
7177+ ? [props.crossOrigin, props.integrity]
7178+ : PRELOAD_NO_CREDS);
7179+ else break b;
7180+ }
7181+ }
7182+ linkHeader ? onHeaders({ Link: linkHeader }) : onHeaders({});
7183+ }
7184+ }
7185+ } catch (error) {
7186+ logRecoverableError(request, error, {}, null);
7187+ }
7188+ }
7189+ function completeShell(request) {
7190+ null === request.trackedPostpones && safelyEmitEarlyPreloads(request, !0);
7191+ null === request.trackedPostpones && preparePreamble(request);
7192+ request.onShellError = noop;
7193+ request = request.onShellReady;
7194+ request();
7195+ }
7196+ function completeAll(request) {
7197+ safelyEmitEarlyPreloads(
7198+ request,
7199+ null === request.trackedPostpones
7200+ ? !0
7201+ : null === request.completedRootSegment ||
7202+ request.completedRootSegment.status !== POSTPONED
7203+ );
7204+ preparePreamble(request);
7205+ request = request.onAllReady;
7206+ request();
7207+ }
7208+ function queueCompletedSegment(boundary, segment) {
7209+ if (
7210+ 0 === segment.chunks.length &&
7211+ 1 === segment.children.length &&
7212+ null === segment.children[0].boundary &&
7213+ -1 === segment.children[0].id
7214+ ) {
7215+ var childSegment = segment.children[0];
7216+ childSegment.id = segment.id;
7217+ childSegment.parentFlushed = !0;
7218+ (childSegment.status !== COMPLETED &&
7219+ childSegment.status !== ABORTED &&
7220+ childSegment.status !== ERRORED) ||
7221+ queueCompletedSegment(boundary, childSegment);
7222+ } else boundary.completedSegments.push(segment);
7223+ }
7224+ function finishedTask(request, boundary, row, segment) {
7225+ null !== row &&
7226+ (0 === --row.pendingTasks
7227+ ? finishSuspenseListRow(request, row)
7228+ : row.together && tryToResolveTogetherRow(request, row));
7229+ request.allPendingTasks--;
7230+ if (null === boundary) {
7231+ if (null !== segment && segment.parentFlushed) {
7232+ if (null !== request.completedRootSegment)
7233+ throw Error(
7234+ "There can only be one root segment. This is a bug in React."
7235+ );
7236+ request.completedRootSegment = segment;
7237+ }
7238+ request.pendingRootTasks--;
7239+ 0 === request.pendingRootTasks && completeShell(request);
7240+ } else if ((boundary.pendingTasks--, boundary.status !== CLIENT_RENDERED))
7241+ if (0 === boundary.pendingTasks)
7242+ if (
7243+ (boundary.status === PENDING && (boundary.status = COMPLETED),
7244+ null !== segment &&
7245+ segment.parentFlushed &&
7246+ (segment.status === COMPLETED || segment.status === ABORTED) &&
7247+ queueCompletedSegment(boundary, segment),
7248+ boundary.parentFlushed &&
7249+ request.completedBoundaries.push(boundary),
7250+ boundary.status === COMPLETED)
7251+ )
7252+ (row = boundary.row),
7253+ null !== row &&
7254+ hoistHoistables(row.hoistables, boundary.contentState),
7255+ isEligibleForOutlining(request, boundary) ||
7256+ (boundary.fallbackAbortableTasks.forEach(
7257+ abortTaskSoft,
7258+ request
7259+ ),
7260+ boundary.fallbackAbortableTasks.clear(),
7261+ null !== row &&
7262+ 0 === --row.pendingTasks &&
7263+ finishSuspenseListRow(request, row)),
7264+ 0 === request.pendingRootTasks &&
7265+ null === request.trackedPostpones &&
7266+ null !== boundary.contentPreamble &&
7267+ preparePreamble(request);
7268+ else {
7269+ if (
7270+ boundary.status === POSTPONED &&
7271+ ((boundary = boundary.row), null !== boundary)
7272+ ) {
7273+ if (null !== request.trackedPostpones) {
7274+ row = request.trackedPostpones;
7275+ var postponedRow = boundary.next;
7276+ if (
7277+ null !== postponedRow &&
7278+ ((segment = postponedRow.boundaries), null !== segment)
7279+ )
7280+ for (
7281+ postponedRow.boundaries = null, postponedRow = 0;
7282+ postponedRow < segment.length;
7283+ postponedRow++
7284+ ) {
7285+ var postponedBoundary = segment[postponedRow];
7286+ trackPostponedBoundary(request, row, postponedBoundary);
7287+ finishedTask(request, postponedBoundary, null, null);
7288+ }
7289+ }
7290+ 0 === --boundary.pendingTasks &&
7291+ finishSuspenseListRow(request, boundary);
7292+ }
7293+ }
7294+ else
7295+ null === segment ||
7296+ !segment.parentFlushed ||
7297+ (segment.status !== COMPLETED && segment.status !== ABORTED) ||
7298+ (queueCompletedSegment(boundary, segment),
7299+ 1 === boundary.completedSegments.length &&
7300+ boundary.parentFlushed &&
7301+ request.partialBoundaries.push(boundary)),
7302+ (boundary = boundary.row),
7303+ null !== boundary &&
7304+ boundary.together &&
7305+ tryToResolveTogetherRow(request, boundary);
7306+ 0 === request.allPendingTasks && completeAll(request);
7307+ }
7308+ function performWork(request$jscomp$2) {
7309+ if (
7310+ request$jscomp$2.status !== CLOSED &&
7311+ 13 !== request$jscomp$2.status
7312+ ) {
7313+ var prevContext = currentActiveSnapshot,
7314+ prevDispatcher = ReactSharedInternals.H;
7315+ ReactSharedInternals.H = HooksDispatcher;
7316+ var prevAsyncDispatcher = ReactSharedInternals.A;
7317+ ReactSharedInternals.A = DefaultAsyncDispatcher;
7318+ var prevRequest = currentRequest;
7319+ currentRequest = request$jscomp$2;
7320+ var prevGetCurrentStackImpl = ReactSharedInternals.getCurrentStack;
7321+ ReactSharedInternals.getCurrentStack = getCurrentStackInDEV;
7322+ var prevResumableState = currentResumableState;
7323+ currentResumableState = request$jscomp$2.resumableState;
7324+ try {
7325+ var pingedTasks = request$jscomp$2.pingedTasks,
7326+ i;
7327+ for (i = 0; i < pingedTasks.length; i++) {
7328+ var request = request$jscomp$2,
7329+ task = pingedTasks[i],
7330+ segment = task.blockedSegment;
7331+ if (null === segment) {
7332+ var prevTaskInDEV = void 0,
7333+ request$jscomp$0 = request;
7334+ request = task;
7335+ if (0 !== request.replay.pendingTasks) {
7336+ switchContext(request.context);
7337+ prevTaskInDEV = currentTaskInDEV;
7338+ currentTaskInDEV = request;
7339+ try {
7340+ "number" === typeof request.replay.slots
7341+ ? resumeNode(
7342+ request$jscomp$0,
7343+ request,
7344+ request.replay.slots,
7345+ request.node,
7346+ request.childIndex
7347+ )
7348+ : retryNode(request$jscomp$0, request);
7349+ if (
7350+ 1 === request.replay.pendingTasks &&
7351+ 0 < request.replay.nodes.length
7352+ )
7353+ throw Error(
7354+ "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
7355+ );
7356+ request.replay.pendingTasks--;
7357+ request.abortSet.delete(request);
7358+ finishedTask(
7359+ request$jscomp$0,
7360+ request.blockedBoundary,
7361+ request.row,
7362+ null
7363+ );
7364+ } catch (thrownValue) {
7365+ resetHooksState();
7366+ var x =
7367+ thrownValue === SuspenseException
7368+ ? getSuspendedThenable()
7369+ : thrownValue;
7370+ if (
7371+ "object" === typeof x &&
7372+ null !== x &&
7373+ "function" === typeof x.then
7374+ ) {
7375+ var ping = request.ping;
7376+ x.then(ping, ping);
7377+ request.thenableState =
7378+ thrownValue === SuspenseException
7379+ ? getThenableStateAfterSuspending()
7380+ : null;
7381+ } else {
7382+ request.replay.pendingTasks--;
7383+ request.abortSet.delete(request);
7384+ var errorInfo = getThrownInfo(request.componentStack),
7385+ errorDigest = void 0,
7386+ request$jscomp$1 = request$jscomp$0,
7387+ boundary = request.blockedBoundary,
7388+ error$jscomp$0 =
7389+ 12 === request$jscomp$0.status
7390+ ? request$jscomp$0.fatalError
7391+ : x,
7392+ errorInfo$jscomp$0 = errorInfo,
7393+ replayNodes = request.replay.nodes,
7394+ resumeSlots = request.replay.slots;
7395+ errorDigest = logRecoverableError(
7396+ request$jscomp$1,
7397+ error$jscomp$0,
7398+ errorInfo$jscomp$0,
7399+ request.debugTask
7400+ );
7401+ abortRemainingReplayNodes(
7402+ request$jscomp$1,
7403+ boundary,
7404+ replayNodes,
7405+ resumeSlots,
7406+ error$jscomp$0,
7407+ errorDigest,
7408+ errorInfo$jscomp$0,
7409+ !1
7410+ );
7411+ request$jscomp$0.pendingRootTasks--;
7412+ 0 === request$jscomp$0.pendingRootTasks &&
7413+ completeShell(request$jscomp$0);
7414+ request$jscomp$0.allPendingTasks--;
7415+ 0 === request$jscomp$0.allPendingTasks &&
7416+ completeAll(request$jscomp$0);
7417+ }
7418+ } finally {
7419+ currentTaskInDEV = prevTaskInDEV;
7420+ }
7421+ }
7422+ } else if (
7423+ ((request$jscomp$0 = prevTaskInDEV = void 0),
7424+ (errorDigest = task),
7425+ (request$jscomp$1 = segment),
7426+ request$jscomp$1.status === PENDING)
7427+ ) {
7428+ request$jscomp$1.status = 6;
7429+ switchContext(errorDigest.context);
7430+ request$jscomp$0 = currentTaskInDEV;
7431+ currentTaskInDEV = errorDigest;
7432+ var childrenLength = request$jscomp$1.children.length,
7433+ chunkLength = request$jscomp$1.chunks.length;
7434+ try {
7435+ retryNode(request, errorDigest),
7436+ pushSegmentFinale(
7437+ request$jscomp$1.chunks,
7438+ request.renderState,
7439+ request$jscomp$1.lastPushedText,
7440+ request$jscomp$1.textEmbedded
7441+ ),
7442+ errorDigest.abortSet.delete(errorDigest),
7443+ (request$jscomp$1.status = COMPLETED),
7444+ finishedTask(
7445+ request,
7446+ errorDigest.blockedBoundary,
7447+ errorDigest.row,
7448+ request$jscomp$1
7449+ );
7450+ } catch (thrownValue) {
7451+ resetHooksState();
7452+ request$jscomp$1.children.length = childrenLength;
7453+ request$jscomp$1.chunks.length = chunkLength;
7454+ var x$jscomp$0 =
7455+ thrownValue === SuspenseException
7456+ ? getSuspendedThenable()
7457+ : 12 === request.status
7458+ ? request.fatalError
7459+ : thrownValue;
7460+ if (
7461+ 12 === request.status &&
7462+ null !== request.trackedPostpones
7463+ ) {
7464+ var trackedPostpones = request.trackedPostpones,
7465+ thrownInfo = getThrownInfo(errorDigest.componentStack);
7466+ errorDigest.abortSet.delete(errorDigest);
7467+ logRecoverableError(
7468+ request,
7469+ x$jscomp$0,
7470+ thrownInfo,
7471+ errorDigest.debugTask
7472+ );
7473+ trackPostpone(
7474+ request,
7475+ trackedPostpones,
7476+ errorDigest,
7477+ request$jscomp$1
7478+ );
7479+ finishedTask(
7480+ request,
7481+ errorDigest.blockedBoundary,
7482+ errorDigest.row,
7483+ request$jscomp$1
7484+ );
7485+ } else if (
7486+ "object" === typeof x$jscomp$0 &&
7487+ null !== x$jscomp$0 &&
7488+ "function" === typeof x$jscomp$0.then
7489+ ) {
7490+ request$jscomp$1.status = PENDING;
7491+ errorDigest.thenableState =
7492+ thrownValue === SuspenseException
7493+ ? getThenableStateAfterSuspending()
7494+ : null;
7495+ var ping$jscomp$0 = errorDigest.ping;
7496+ x$jscomp$0.then(ping$jscomp$0, ping$jscomp$0);
7497+ } else {
7498+ var errorInfo$jscomp$1 = getThrownInfo(
7499+ errorDigest.componentStack
7500+ );
7501+ errorDigest.abortSet.delete(errorDigest);
7502+ request$jscomp$1.status = ERRORED;
7503+ var boundary$jscomp$0 = errorDigest.blockedBoundary,
7504+ row = errorDigest.row,
7505+ debugTask = errorDigest.debugTask;
7506+ null !== row &&
7507+ 0 === --row.pendingTasks &&
7508+ finishSuspenseListRow(request, row);
7509+ request.allPendingTasks--;
7510+ prevTaskInDEV = logRecoverableError(
7511+ request,
7512+ x$jscomp$0,
7513+ errorInfo$jscomp$1,
7514+ debugTask
7515+ );
7516+ if (null === boundary$jscomp$0)
7517+ fatalError(
7518+ request,
7519+ x$jscomp$0,
7520+ errorInfo$jscomp$1,
7521+ debugTask
7522+ );
7523+ else if (
7524+ (boundary$jscomp$0.pendingTasks--,
7525+ boundary$jscomp$0.status !== CLIENT_RENDERED)
7526+ ) {
7527+ boundary$jscomp$0.status = CLIENT_RENDERED;
7528+ encodeErrorForBoundary(
7529+ boundary$jscomp$0,
7530+ prevTaskInDEV,
7531+ x$jscomp$0,
7532+ errorInfo$jscomp$1,
7533+ !1
7534+ );
7535+ untrackBoundary(request, boundary$jscomp$0);
7536+ var boundaryRow = boundary$jscomp$0.row;
7537+ null !== boundaryRow &&
7538+ 0 === --boundaryRow.pendingTasks &&
7539+ finishSuspenseListRow(request, boundaryRow);
7540+ boundary$jscomp$0.parentFlushed &&
7541+ request.clientRenderedBoundaries.push(boundary$jscomp$0);
7542+ 0 === request.pendingRootTasks &&
7543+ null === request.trackedPostpones &&
7544+ null !== boundary$jscomp$0.contentPreamble &&
7545+ preparePreamble(request);
7546+ }
7547+ 0 === request.allPendingTasks && completeAll(request);
7548+ }
7549+ } finally {
7550+ currentTaskInDEV = request$jscomp$0;
7551+ }
7552+ }
7553+ }
7554+ pingedTasks.splice(0, i);
7555+ null !== request$jscomp$2.destination &&
7556+ flushCompletedQueues(
7557+ request$jscomp$2,
7558+ request$jscomp$2.destination
7559+ );
7560+ } catch (error) {
7561+ (pingedTasks = {}),
7562+ logRecoverableError(request$jscomp$2, error, pingedTasks, null),
7563+ fatalError(request$jscomp$2, error, pingedTasks, null);
7564+ } finally {
7565+ (currentResumableState = prevResumableState),
7566+ (ReactSharedInternals.H = prevDispatcher),
7567+ (ReactSharedInternals.A = prevAsyncDispatcher),
7568+ (ReactSharedInternals.getCurrentStack = prevGetCurrentStackImpl),
7569+ prevDispatcher === HooksDispatcher && switchContext(prevContext),
7570+ (currentRequest = prevRequest);
7571+ }
68747572 }
68757573 }
6876−
6877− partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
6878− // boundaries added to it in case they were too larged to be inlined.
6879− // New ones might be added in this loop.
6880−
6881− var largeBoundaries = request.completedBoundaries;
6882−
6883− for (i = 0; i < largeBoundaries.length; i++) {
6884− var _boundary3 = largeBoundaries[i];
6885−
6886− if (!flushCompletedBoundary(request, destination, _boundary3)) {
6887− request.destination = null;
6888− i++;
6889− largeBoundaries.splice(0, i);
6890− return;
7574+ function preparePreambleFromSubtree(
7575+ request,
7576+ segment,
7577+ collectedPreambleSegments
7578+ ) {
7579+ segment.preambleChildren.length &&
7580+ collectedPreambleSegments.push(segment.preambleChildren);
7581+ for (var pendingPreambles = !1, i = 0; i < segment.children.length; i++)
7582+ pendingPreambles =
7583+ preparePreambleFromSegment(
7584+ request,
7585+ segment.children[i],
7586+ collectedPreambleSegments
7587+ ) || pendingPreambles;
7588+ return pendingPreambles;
7589+ }
7590+ function preparePreambleFromSegment(
7591+ request,
7592+ segment,
7593+ collectedPreambleSegments
7594+ ) {
7595+ var boundary = segment.boundary;
7596+ if (null === boundary)
7597+ return preparePreambleFromSubtree(
7598+ request,
7599+ segment,
7600+ collectedPreambleSegments
7601+ );
7602+ var preamble = boundary.contentPreamble,
7603+ fallbackPreamble = boundary.fallbackPreamble;
7604+ if (null === preamble || null === fallbackPreamble) return !1;
7605+ switch (boundary.status) {
7606+ case COMPLETED:
7607+ hoistPreambleState(request.renderState, preamble);
7608+ request.byteSize += boundary.byteSize;
7609+ segment = boundary.completedSegments[0];
7610+ if (!segment)
7611+ throw Error(
7612+ "A previously unvisited boundary must have exactly one root segment. This is a bug in React."
7613+ );
7614+ return preparePreambleFromSubtree(
7615+ request,
7616+ segment,
7617+ collectedPreambleSegments
7618+ );
7619+ case POSTPONED:
7620+ if (null !== request.trackedPostpones) return !0;
7621+ case CLIENT_RENDERED:
7622+ if (segment.status === COMPLETED)
7623+ return (
7624+ hoistPreambleState(request.renderState, fallbackPreamble),
7625+ preparePreambleFromSubtree(
7626+ request,
7627+ segment,
7628+ collectedPreambleSegments
7629+ )
7630+ );
7631+ default:
7632+ return !0;
7633+ }
7634+ }
7635+ function preparePreamble(request) {
7636+ if (
7637+ request.completedRootSegment &&
7638+ null === request.completedPreambleSegments
7639+ ) {
7640+ var collectedPreambleSegments = [],
7641+ originalRequestByteSize = request.byteSize,
7642+ hasPendingPreambles = preparePreambleFromSegment(
7643+ request,
7644+ request.completedRootSegment,
7645+ collectedPreambleSegments
7646+ ),
7647+ preamble = request.renderState.preamble;
7648+ !1 === hasPendingPreambles ||
7649+ (preamble.headChunks && preamble.bodyChunks)
7650+ ? (request.completedPreambleSegments = collectedPreambleSegments)
7651+ : (request.byteSize = originalRequestByteSize);
7652+ }
7653+ }
7654+ function flushSubtree(request, destination, segment, hoistableState) {
7655+ segment.parentFlushed = !0;
7656+ switch (segment.status) {
7657+ case PENDING:
7658+ segment.id = request.nextSegmentId++;
7659+ case POSTPONED:
7660+ return (
7661+ (hoistableState = segment.id),
7662+ (segment.lastPushedText = !1),
7663+ (segment.textEmbedded = !1),
7664+ (request = request.renderState),
7665+ destination.push(placeholder1),
7666+ destination.push(request.placeholderPrefix),
7667+ (request = hoistableState.toString(16)),
7668+ destination.push(request),
7669+ destination.push(placeholder2)
7670+ );
7671+ case COMPLETED:
7672+ segment.status = FLUSHED;
7673+ var r = !0,
7674+ chunks = segment.chunks,
7675+ chunkIdx = 0;
7676+ segment = segment.children;
7677+ for (var childIdx = 0; childIdx < segment.length; childIdx++) {
7678+ for (r = segment[childIdx]; chunkIdx < r.index; chunkIdx++)
7679+ destination.push(chunks[chunkIdx]);
7680+ r = flushSegment(request, destination, r, hoistableState);
7681+ }
7682+ for (; chunkIdx < chunks.length - 1; chunkIdx++)
7683+ destination.push(chunks[chunkIdx]);
7684+ chunkIdx < chunks.length && (r = destination.push(chunks[chunkIdx]));
7685+ return r;
7686+ case ABORTED:
7687+ return !0;
7688+ default:
7689+ throw Error(
7690+ "Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React."
7691+ );
7692+ }
7693+ }
7694+ function flushSegment(request, destination, segment, hoistableState) {
7695+ var boundary = segment.boundary;
7696+ if (null === boundary)
7697+ return flushSubtree(request, destination, segment, hoistableState);
7698+ boundary.parentFlushed = !0;
7699+ if (boundary.status === CLIENT_RENDERED) {
7700+ var row = boundary.row;
7701+ null !== row &&
7702+ 0 === --row.pendingTasks &&
7703+ finishSuspenseListRow(request, row);
7704+ if (!request.renderState.generateStaticMarkup) {
7705+ var errorDigest = boundary.errorDigest,
7706+ errorMessage = boundary.errorMessage;
7707+ row = boundary.errorStack;
7708+ boundary = boundary.errorComponentStack;
7709+ destination.push(startClientRenderedSuspenseBoundary);
7710+ destination.push(clientRenderedSuspenseBoundaryError1);
7711+ errorDigest &&
7712+ (destination.push(clientRenderedSuspenseBoundaryError1A),
7713+ (errorDigest = escapeTextForBrowser(errorDigest)),
7714+ destination.push(errorDigest),
7715+ destination.push(
7716+ clientRenderedSuspenseBoundaryErrorAttrInterstitial
7717+ ));
7718+ errorMessage &&
7719+ (destination.push(clientRenderedSuspenseBoundaryError1B),
7720+ (errorMessage = escapeTextForBrowser(errorMessage)),
7721+ destination.push(errorMessage),
7722+ destination.push(
7723+ clientRenderedSuspenseBoundaryErrorAttrInterstitial
7724+ ));
7725+ row &&
7726+ (destination.push(clientRenderedSuspenseBoundaryError1C),
7727+ (row = escapeTextForBrowser(row)),
7728+ destination.push(row),
7729+ destination.push(
7730+ clientRenderedSuspenseBoundaryErrorAttrInterstitial
7731+ ));
7732+ boundary &&
7733+ (destination.push(clientRenderedSuspenseBoundaryError1D),
7734+ (row = escapeTextForBrowser(boundary)),
7735+ destination.push(row),
7736+ destination.push(
7737+ clientRenderedSuspenseBoundaryErrorAttrInterstitial
7738+ ));
7739+ destination.push(clientRenderedSuspenseBoundaryError2);
7740+ }
7741+ flushSubtree(request, destination, segment, hoistableState);
7742+ request = request.renderState.generateStaticMarkup
7743+ ? !0
7744+ : destination.push(endSuspenseBoundary);
7745+ return request;
7746+ }
7747+ if (boundary.status !== COMPLETED)
7748+ return (
7749+ boundary.status === PENDING &&
7750+ (boundary.rootSegmentID = request.nextSegmentId++),
7751+ 0 < boundary.completedSegments.length &&
7752+ request.partialBoundaries.push(boundary),
7753+ writeStartPendingSuspenseBoundary(
7754+ destination,
7755+ request.renderState,
7756+ boundary.rootSegmentID
7757+ ),
7758+ hoistableState &&
7759+ hoistHoistables(hoistableState, boundary.fallbackState),
7760+ flushSubtree(request, destination, segment, hoistableState),
7761+ destination.push(endSuspenseBoundary)
7762+ );
7763+ if (
7764+ !flushingPartialBoundaries &&
7765+ isEligibleForOutlining(request, boundary) &&
7766+ flushedByteSize + boundary.byteSize > request.progressiveChunkSize
7767+ )
7768+ return (
7769+ (boundary.rootSegmentID = request.nextSegmentId++),
7770+ request.completedBoundaries.push(boundary),
7771+ writeStartPendingSuspenseBoundary(
7772+ destination,
7773+ request.renderState,
7774+ boundary.rootSegmentID
7775+ ),
7776+ flushSubtree(request, destination, segment, hoistableState),
7777+ destination.push(endSuspenseBoundary)
7778+ );
7779+ flushedByteSize += boundary.byteSize;
7780+ hoistableState && hoistHoistables(hoistableState, boundary.contentState);
7781+ segment = boundary.row;
7782+ null !== segment &&
7783+ isEligibleForOutlining(request, boundary) &&
7784+ 0 === --segment.pendingTasks &&
7785+ finishSuspenseListRow(request, segment);
7786+ request.renderState.generateStaticMarkup ||
7787+ destination.push(startCompletedSuspenseBoundary);
7788+ segment = boundary.completedSegments;
7789+ if (1 !== segment.length)
7790+ throw Error(
7791+ "A previously unvisited boundary must have exactly one root segment. This is a bug in React."
7792+ );
7793+ flushSegment(request, destination, segment[0], hoistableState);
7794+ request = request.renderState.generateStaticMarkup
7795+ ? !0
7796+ : destination.push(endSuspenseBoundary);
7797+ return request;
7798+ }
7799+ function flushSegmentContainer(
7800+ request,
7801+ destination,
7802+ segment,
7803+ hoistableState
7804+ ) {
7805+ writeStartSegment(
7806+ destination,
7807+ request.renderState,
7808+ segment.parentFormatContext,
7809+ segment.id
7810+ );
7811+ flushSegment(request, destination, segment, hoistableState);
7812+ return writeEndSegment(destination, segment.parentFormatContext);
7813+ }
7814+ function flushCompletedBoundary(request, destination, boundary) {
7815+ flushedByteSize = boundary.byteSize;
7816+ for (
7817+ var completedSegments = boundary.completedSegments, i = 0;
7818+ i < completedSegments.length;
7819+ i++
7820+ )
7821+ flushPartiallyCompletedSegment(
7822+ request,
7823+ destination,
7824+ boundary,
7825+ completedSegments[i]
7826+ );
7827+ completedSegments.length = 0;
7828+ completedSegments = boundary.row;
7829+ null !== completedSegments &&
7830+ isEligibleForOutlining(request, boundary) &&
7831+ 0 === --completedSegments.pendingTasks &&
7832+ finishSuspenseListRow(request, completedSegments);
7833+ writeHoistablesForBoundary(
7834+ destination,
7835+ boundary.contentState,
7836+ request.renderState
7837+ );
7838+ completedSegments = request.resumableState;
7839+ request = request.renderState;
7840+ i = boundary.rootSegmentID;
7841+ boundary = boundary.contentState;
7842+ var requiresStyleInsertion = request.stylesToHoist;
7843+ request.stylesToHoist = !1;
7844+ destination.push(request.startInlineScript);
7845+ destination.push(endOfStartTag);
7846+ requiresStyleInsertion
7847+ ? ((completedSegments.instructions & SentClientRenderFunction) ===
7848+ NothingSent &&
7849+ ((completedSegments.instructions |= SentClientRenderFunction),
7850+ destination.push(clientRenderScriptFunctionOnly)),
7851+ (completedSegments.instructions & SentCompleteBoundaryFunction) ===
7852+ NothingSent &&
7853+ ((completedSegments.instructions |= SentCompleteBoundaryFunction),
7854+ destination.push(completeBoundaryScriptFunctionOnly)),
7855+ (completedSegments.instructions & SentStyleInsertionFunction) ===
7856+ NothingSent
7857+ ? ((completedSegments.instructions |= SentStyleInsertionFunction),
7858+ destination.push(completeBoundaryWithStylesScript1FullPartial))
7859+ : destination.push(completeBoundaryWithStylesScript1Partial))
7860+ : ((completedSegments.instructions & SentCompleteBoundaryFunction) ===
7861+ NothingSent &&
7862+ ((completedSegments.instructions |= SentCompleteBoundaryFunction),
7863+ destination.push(completeBoundaryScriptFunctionOnly)),
7864+ destination.push(completeBoundaryScript1Partial));
7865+ completedSegments = i.toString(16);
7866+ destination.push(request.boundaryPrefix);
7867+ destination.push(completedSegments);
7868+ destination.push(completeBoundaryScript2);
7869+ destination.push(request.segmentPrefix);
7870+ destination.push(completedSegments);
7871+ requiresStyleInsertion
7872+ ? (destination.push(completeBoundaryScript3a),
7873+ writeStyleResourceDependenciesInJS(destination, boundary))
7874+ : destination.push(completeBoundaryScript3b);
7875+ boundary = destination.push(completeBoundaryScriptEnd);
7876+ return writeBootstrap(destination, request) && boundary;
7877+ }
7878+ function flushPartiallyCompletedSegment(
7879+ request,
7880+ destination,
7881+ boundary,
7882+ segment
7883+ ) {
7884+ if (segment.status === FLUSHED) return !0;
7885+ var hoistableState = boundary.contentState,
7886+ segmentID = segment.id;
7887+ if (-1 === segmentID) {
7888+ if (-1 === (segment.id = boundary.rootSegmentID))
7889+ throw Error(
7890+ "A root segment ID must have been assigned by now. This is a bug in React."
7891+ );
7892+ return flushSegmentContainer(
7893+ request,
7894+ destination,
7895+ segment,
7896+ hoistableState
7897+ );
7898+ }
7899+ if (segmentID === boundary.rootSegmentID)
7900+ return flushSegmentContainer(
7901+ request,
7902+ destination,
7903+ segment,
7904+ hoistableState
7905+ );
7906+ flushSegmentContainer(request, destination, segment, hoistableState);
7907+ boundary = request.resumableState;
7908+ request = request.renderState;
7909+ destination.push(request.startInlineScript);
7910+ destination.push(endOfStartTag);
7911+ (boundary.instructions & SentCompleteSegmentFunction) === NothingSent
7912+ ? ((boundary.instructions |= SentCompleteSegmentFunction),
7913+ destination.push(completeSegmentScript1Full))
7914+ : destination.push(completeSegmentScript1Partial);
7915+ destination.push(request.segmentPrefix);
7916+ segmentID = segmentID.toString(16);
7917+ destination.push(segmentID);
7918+ destination.push(completeSegmentScript2);
7919+ destination.push(request.placeholderPrefix);
7920+ destination.push(segmentID);
7921+ destination = destination.push(completeSegmentScriptEnd);
7922+ return destination;
7923+ }
7924+ function flushCompletedQueues(request, destination) {
7925+ try {
7926+ if (!(0 < request.pendingRootTasks)) {
7927+ var i,
7928+ completedRootSegment = request.completedRootSegment;
7929+ if (null !== completedRootSegment) {
7930+ if (completedRootSegment.status === POSTPONED) return;
7931+ var completedPreambleSegments = request.completedPreambleSegments;
7932+ if (null === completedPreambleSegments) return;
7933+ flushedByteSize = request.byteSize;
7934+ var resumableState = request.resumableState,
7935+ renderState = request.renderState,
7936+ preamble = renderState.preamble,
7937+ htmlChunks = preamble.htmlChunks,
7938+ headChunks = preamble.headChunks,
7939+ i$jscomp$0;
7940+ if (htmlChunks) {
7941+ for (i$jscomp$0 = 0; i$jscomp$0 < htmlChunks.length; i$jscomp$0++)
7942+ destination.push(htmlChunks[i$jscomp$0]);
7943+ if (headChunks)
7944+ for (
7945+ i$jscomp$0 = 0;
7946+ i$jscomp$0 < headChunks.length;
7947+ i$jscomp$0++
7948+ )
7949+ destination.push(headChunks[i$jscomp$0]);
7950+ else {
7951+ var chunk = startChunkForTag("head");
7952+ destination.push(chunk);
7953+ destination.push(endOfStartTag);
7954+ }
7955+ } else if (headChunks)
7956+ for (i$jscomp$0 = 0; i$jscomp$0 < headChunks.length; i$jscomp$0++)
7957+ destination.push(headChunks[i$jscomp$0]);
7958+ var charsetChunks = renderState.charsetChunks;
7959+ for (
7960+ i$jscomp$0 = 0;
7961+ i$jscomp$0 < charsetChunks.length;
7962+ i$jscomp$0++
7963+ )
7964+ destination.push(charsetChunks[i$jscomp$0]);
7965+ charsetChunks.length = 0;
7966+ renderState.preconnects.forEach(flushResource, destination);
7967+ renderState.preconnects.clear();
7968+ var viewportChunks = renderState.viewportChunks;
7969+ for (
7970+ i$jscomp$0 = 0;
7971+ i$jscomp$0 < viewportChunks.length;
7972+ i$jscomp$0++
7973+ )
7974+ destination.push(viewportChunks[i$jscomp$0]);
7975+ viewportChunks.length = 0;
7976+ renderState.fontPreloads.forEach(flushResource, destination);
7977+ renderState.fontPreloads.clear();
7978+ renderState.highImagePreloads.forEach(flushResource, destination);
7979+ renderState.highImagePreloads.clear();
7980+ currentlyFlushingRenderState = renderState;
7981+ renderState.styles.forEach(flushStylesInPreamble, destination);
7982+ currentlyFlushingRenderState = null;
7983+ var importMapChunks = renderState.importMapChunks;
7984+ for (
7985+ i$jscomp$0 = 0;
7986+ i$jscomp$0 < importMapChunks.length;
7987+ i$jscomp$0++
7988+ )
7989+ destination.push(importMapChunks[i$jscomp$0]);
7990+ importMapChunks.length = 0;
7991+ renderState.bootstrapScripts.forEach(flushResource, destination);
7992+ renderState.scripts.forEach(flushResource, destination);
7993+ renderState.scripts.clear();
7994+ renderState.bulkPreloads.forEach(flushResource, destination);
7995+ renderState.bulkPreloads.clear();
7996+ resumableState.instructions |= SentCompletedShellId;
7997+ var hoistableChunks = renderState.hoistableChunks;
7998+ for (
7999+ i$jscomp$0 = 0;
8000+ i$jscomp$0 < hoistableChunks.length;
8001+ i$jscomp$0++
8002+ )
8003+ destination.push(hoistableChunks[i$jscomp$0]);
8004+ for (
8005+ resumableState = hoistableChunks.length = 0;
8006+ resumableState < completedPreambleSegments.length;
8007+ resumableState++
8008+ ) {
8009+ var segments = completedPreambleSegments[resumableState];
8010+ for (
8011+ renderState = 0;
8012+ renderState < segments.length;
8013+ renderState++
8014+ )
8015+ flushSegment(request, destination, segments[renderState], null);
8016+ }
8017+ var preamble$jscomp$0 = request.renderState.preamble,
8018+ headChunks$jscomp$0 = preamble$jscomp$0.headChunks;
8019+ if (preamble$jscomp$0.htmlChunks || headChunks$jscomp$0) {
8020+ var chunk$jscomp$0 = endChunkForTag("head");
8021+ destination.push(chunk$jscomp$0);
8022+ }
8023+ var bodyChunks = preamble$jscomp$0.bodyChunks;
8024+ if (bodyChunks)
8025+ for (
8026+ completedPreambleSegments = 0;
8027+ completedPreambleSegments < bodyChunks.length;
8028+ completedPreambleSegments++
8029+ )
8030+ destination.push(bodyChunks[completedPreambleSegments]);
8031+ flushSegment(request, destination, completedRootSegment, null);
8032+ request.completedRootSegment = null;
8033+ var renderState$jscomp$0 = request.renderState;
8034+ if (
8035+ 0 !== request.allPendingTasks ||
8036+ 0 !== request.clientRenderedBoundaries.length ||
8037+ 0 !== request.completedBoundaries.length ||
8038+ (null !== request.trackedPostpones &&
8039+ (0 !== request.trackedPostpones.rootNodes.length ||
8040+ null !== request.trackedPostpones.rootSlots))
8041+ ) {
8042+ var resumableState$jscomp$0 = request.resumableState;
8043+ if (
8044+ (resumableState$jscomp$0.instructions & SentMarkShellTime) ===
8045+ NothingSent
8046+ ) {
8047+ resumableState$jscomp$0.instructions |= SentMarkShellTime;
8048+ destination.push(renderState$jscomp$0.startInlineScript);
8049+ if (
8050+ (resumableState$jscomp$0.instructions &
8051+ SentCompletedShellId) ===
8052+ NothingSent
8053+ ) {
8054+ resumableState$jscomp$0.instructions |= SentCompletedShellId;
8055+ var shellId = "_" + resumableState$jscomp$0.idPrefix + "R_";
8056+ destination.push(completedShellIdAttributeStart);
8057+ var chunk$jscomp$1 = escapeTextForBrowser(shellId);
8058+ destination.push(chunk$jscomp$1);
8059+ destination.push(attributeEnd);
8060+ }
8061+ destination.push(endOfStartTag);
8062+ destination.push(shellTimeRuntimeScript);
8063+ destination.push(endInlineScript);
8064+ }
8065+ }
8066+ writeBootstrap(destination, renderState$jscomp$0);
8067+ }
8068+ var renderState$jscomp$1 = request.renderState;
8069+ completedRootSegment = 0;
8070+ var viewportChunks$jscomp$0 = renderState$jscomp$1.viewportChunks;
8071+ for (
8072+ completedRootSegment = 0;
8073+ completedRootSegment < viewportChunks$jscomp$0.length;
8074+ completedRootSegment++
8075+ )
8076+ destination.push(viewportChunks$jscomp$0[completedRootSegment]);
8077+ viewportChunks$jscomp$0.length = 0;
8078+ renderState$jscomp$1.preconnects.forEach(flushResource, destination);
8079+ renderState$jscomp$1.preconnects.clear();
8080+ renderState$jscomp$1.fontPreloads.forEach(flushResource, destination);
8081+ renderState$jscomp$1.fontPreloads.clear();
8082+ renderState$jscomp$1.highImagePreloads.forEach(
8083+ flushResource,
8084+ destination
8085+ );
8086+ renderState$jscomp$1.highImagePreloads.clear();
8087+ renderState$jscomp$1.styles.forEach(preloadLateStyles, destination);
8088+ renderState$jscomp$1.scripts.forEach(flushResource, destination);
8089+ renderState$jscomp$1.scripts.clear();
8090+ renderState$jscomp$1.bulkPreloads.forEach(flushResource, destination);
8091+ renderState$jscomp$1.bulkPreloads.clear();
8092+ var hoistableChunks$jscomp$0 = renderState$jscomp$1.hoistableChunks;
8093+ for (
8094+ completedRootSegment = 0;
8095+ completedRootSegment < hoistableChunks$jscomp$0.length;
8096+ completedRootSegment++
8097+ )
8098+ destination.push(hoistableChunks$jscomp$0[completedRootSegment]);
8099+ hoistableChunks$jscomp$0.length = 0;
8100+ var clientRenderedBoundaries = request.clientRenderedBoundaries;
8101+ for (i = 0; i < clientRenderedBoundaries.length; i++) {
8102+ var boundary = clientRenderedBoundaries[i];
8103+ renderState$jscomp$1 = destination;
8104+ var resumableState$jscomp$1 = request.resumableState,
8105+ renderState$jscomp$2 = request.renderState,
8106+ id = boundary.rootSegmentID,
8107+ errorDigest = boundary.errorDigest,
8108+ errorMessage = boundary.errorMessage,
8109+ errorStack = boundary.errorStack,
8110+ errorComponentStack = boundary.errorComponentStack;
8111+ renderState$jscomp$1.push(renderState$jscomp$2.startInlineScript);
8112+ renderState$jscomp$1.push(endOfStartTag);
8113+ (resumableState$jscomp$1.instructions &
8114+ SentClientRenderFunction) ===
8115+ NothingSent
8116+ ? ((resumableState$jscomp$1.instructions |=
8117+ SentClientRenderFunction),
8118+ renderState$jscomp$1.push(clientRenderScript1Full))
8119+ : renderState$jscomp$1.push(clientRenderScript1Partial);
8120+ renderState$jscomp$1.push(renderState$jscomp$2.boundaryPrefix);
8121+ var chunk$jscomp$2 = id.toString(16);
8122+ renderState$jscomp$1.push(chunk$jscomp$2);
8123+ renderState$jscomp$1.push(clientRenderScript1A);
8124+ if (
8125+ errorDigest ||
8126+ errorMessage ||
8127+ errorStack ||
8128+ errorComponentStack
8129+ ) {
8130+ renderState$jscomp$1.push(clientRenderErrorScriptArgInterstitial);
8131+ var chunk$jscomp$3 = escapeJSStringsForInstructionScripts(
8132+ errorDigest || ""
8133+ );
8134+ renderState$jscomp$1.push(chunk$jscomp$3);
8135+ }
8136+ if (errorMessage || errorStack || errorComponentStack) {
8137+ renderState$jscomp$1.push(clientRenderErrorScriptArgInterstitial);
8138+ var chunk$jscomp$4 = escapeJSStringsForInstructionScripts(
8139+ errorMessage || ""
8140+ );
8141+ renderState$jscomp$1.push(chunk$jscomp$4);
8142+ }
8143+ if (errorStack || errorComponentStack) {
8144+ renderState$jscomp$1.push(clientRenderErrorScriptArgInterstitial);
8145+ var chunk$jscomp$5 = escapeJSStringsForInstructionScripts(
8146+ errorStack || ""
8147+ );
8148+ renderState$jscomp$1.push(chunk$jscomp$5);
8149+ }
8150+ if (errorComponentStack) {
8151+ renderState$jscomp$1.push(clientRenderErrorScriptArgInterstitial);
8152+ var chunk$jscomp$6 =
8153+ escapeJSStringsForInstructionScripts(errorComponentStack);
8154+ renderState$jscomp$1.push(chunk$jscomp$6);
8155+ }
8156+ var JSCompiler_inline_result = renderState$jscomp$1.push(
8157+ clientRenderScriptEnd
8158+ );
8159+ if (!JSCompiler_inline_result) {
8160+ request.destination = null;
8161+ i++;
8162+ clientRenderedBoundaries.splice(0, i);
8163+ return;
8164+ }
8165+ }
8166+ clientRenderedBoundaries.splice(0, i);
8167+ var completedBoundaries = request.completedBoundaries;
8168+ for (i = 0; i < completedBoundaries.length; i++)
8169+ if (
8170+ !flushCompletedBoundary(
8171+ request,
8172+ destination,
8173+ completedBoundaries[i]
8174+ )
8175+ ) {
8176+ request.destination = null;
8177+ i++;
8178+ completedBoundaries.splice(0, i);
8179+ return;
8180+ }
8181+ completedBoundaries.splice(0, i);
8182+ flushingPartialBoundaries = !0;
8183+ var partialBoundaries = request.partialBoundaries;
8184+ for (i = 0; i < partialBoundaries.length; i++) {
8185+ a: {
8186+ clientRenderedBoundaries = request;
8187+ boundary = destination;
8188+ var boundary$jscomp$0 = partialBoundaries[i];
8189+ flushedByteSize = boundary$jscomp$0.byteSize;
8190+ var completedSegments = boundary$jscomp$0.completedSegments;
8191+ for (
8192+ JSCompiler_inline_result = 0;
8193+ JSCompiler_inline_result < completedSegments.length;
8194+ JSCompiler_inline_result++
8195+ )
8196+ if (
8197+ !flushPartiallyCompletedSegment(
8198+ clientRenderedBoundaries,
8199+ boundary,
8200+ boundary$jscomp$0,
8201+ completedSegments[JSCompiler_inline_result]
8202+ )
8203+ ) {
8204+ JSCompiler_inline_result++;
8205+ completedSegments.splice(0, JSCompiler_inline_result);
8206+ var JSCompiler_inline_result$jscomp$0 = !1;
8207+ break a;
8208+ }
8209+ completedSegments.splice(0, JSCompiler_inline_result);
8210+ var row = boundary$jscomp$0.row;
8211+ null !== row &&
8212+ row.together &&
8213+ 1 === boundary$jscomp$0.pendingTasks &&
8214+ (1 === row.pendingTasks
8215+ ? unblockSuspenseListRow(
8216+ clientRenderedBoundaries,
8217+ row,
8218+ row.hoistables
8219+ )
8220+ : row.pendingTasks--);
8221+ JSCompiler_inline_result$jscomp$0 = writeHoistablesForBoundary(
8222+ boundary,
8223+ boundary$jscomp$0.contentState,
8224+ clientRenderedBoundaries.renderState
8225+ );
8226+ }
8227+ if (!JSCompiler_inline_result$jscomp$0) {
8228+ request.destination = null;
8229+ i++;
8230+ partialBoundaries.splice(0, i);
8231+ return;
8232+ }
8233+ }
8234+ partialBoundaries.splice(0, i);
8235+ flushingPartialBoundaries = !1;
8236+ var largeBoundaries = request.completedBoundaries;
8237+ for (i = 0; i < largeBoundaries.length; i++)
8238+ if (
8239+ !flushCompletedBoundary(request, destination, largeBoundaries[i])
8240+ ) {
8241+ request.destination = null;
8242+ i++;
8243+ largeBoundaries.splice(0, i);
8244+ return;
8245+ }
8246+ largeBoundaries.splice(0, i);
8247+ }
8248+ } finally {
8249+ (flushingPartialBoundaries = !1),
8250+ 0 === request.allPendingTasks &&
8251+ 0 === request.clientRenderedBoundaries.length &&
8252+ 0 === request.completedBoundaries.length &&
8253+ ((request.flushScheduled = !1),
8254+ (i = request.resumableState),
8255+ i.hasBody &&
8256+ ((partialBoundaries = endChunkForTag("body")),
8257+ destination.push(partialBoundaries)),
8258+ i.hasHtml && ((i = endChunkForTag("html")), destination.push(i)),
8259+ 0 !== request.abortableTasks.size &&
8260+ console.error(
8261+ "There was still abortable task at the root when we closed. This is a bug in React."
8262+ ),
8263+ (request.status = CLOSED),
8264+ destination.push(null),
8265+ (request.destination = null));
8266+ }
8267+ }
8268+ function startWork(request) {
8269+ request.flushScheduled = null !== request.destination;
8270+ performWork(request);
8271+ 10 === request.status && (request.status = 11);
8272+ null === request.trackedPostpones &&
8273+ safelyEmitEarlyPreloads(request, 0 === request.pendingRootTasks);
8274+ }
8275+ function enqueueFlush(request) {
8276+ if (
8277+ !1 === request.flushScheduled &&
8278+ 0 === request.pingedTasks.length &&
8279+ null !== request.destination
8280+ ) {
8281+ request.flushScheduled = !0;
8282+ var destination = request.destination;
8283+ destination
8284+ ? flushCompletedQueues(request, destination)
8285+ : (request.flushScheduled = !1);
8286+ }
8287+ }
8288+ function startFlowing(request, destination) {
8289+ if (13 === request.status)
8290+ (request.status = CLOSED), destination.destroy(request.fatalError);
8291+ else if (request.status !== CLOSED && null === request.destination) {
8292+ request.destination = destination;
8293+ try {
8294+ flushCompletedQueues(request, destination);
8295+ } catch (error) {
8296+ (destination = {}),
8297+ logRecoverableError(request, error, destination, null),
8298+ fatalError(request, error, destination, null);
8299+ }
68918300 }
68928301 }
6893−
6894− largeBoundaries.splice(0, i);
6895− } finally {
6896−
6897− if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
6898− // either they have pending task or they're complete.
8302+ function abort(request, reason) {
8303+ if (11 === request.status || 10 === request.status) request.status = 12;
8304+ try {
8305+ var abortableTasks = request.abortableTasks;
8306+ if (0 < abortableTasks.size) {
8307+ var error =
8308+ void 0 === reason
8309+ ? Error("The render was aborted by the server without a reason.")
8310+ : "object" === typeof reason &&
8311+ null !== reason &&
8312+ "function" === typeof reason.then
8313+ ? Error("The render was aborted by the server with a promise.")
8314+ : reason;
8315+ request.fatalError = error;
8316+ abortableTasks.forEach(function (task) {
8317+ var prevTaskInDEV = currentTaskInDEV,
8318+ prevGetCurrentStackImpl = ReactSharedInternals.getCurrentStack;
8319+ currentTaskInDEV = task;
8320+ ReactSharedInternals.getCurrentStack = getCurrentStackInDEV;
8321+ try {
8322+ abortTask(task, request, error);
8323+ } finally {
8324+ (currentTaskInDEV = prevTaskInDEV),
8325+ (ReactSharedInternals.getCurrentStack =
8326+ prevGetCurrentStackImpl);
8327+ }
8328+ });
8329+ abortableTasks.clear();
8330+ }
8331+ null !== request.destination &&
8332+ flushCompletedQueues(request, request.destination);
8333+ } catch (error$4) {
8334+ (reason = {}),
8335+ logRecoverableError(request, error$4, reason, null),
8336+ fatalError(request, error$4, reason, null);
8337+ }
8338+ }
8339+ function addToReplayParent(node, parentKeyPath, trackedPostpones) {
8340+ if (null === parentKeyPath) trackedPostpones.rootNodes.push(node);
8341+ else {
8342+ var workingMap = trackedPostpones.workingMap,
8343+ parentNode = workingMap.get(parentKeyPath);
8344+ void 0 === parentNode &&
8345+ ((parentNode = [parentKeyPath[1], parentKeyPath[2], [], null]),
8346+ workingMap.set(parentKeyPath, parentNode),
8347+ addToReplayParent(parentNode, parentKeyPath[0], trackedPostpones));
8348+ parentNode[2].push(node);
8349+ }
8350+ }
8351+ function onError() {}
8352+ function renderToStringImpl(
8353+ children,
8354+ options,
8355+ generateStaticMarkup,
8356+ abortReason
68998357 ) {
6900− {
6901− if (request.abortableTasks.size !== 0) {
6902− error('There was still abortable task at the root when we closed. This is a bug in React.');
8358+ var didFatal = !1,
8359+ fatalError = null,
8360+ result = "",
8361+ readyToStream = !1;
8362+ options = createResumableState(
8363+ options ? options.identifierPrefix : void 0
8364+ );
8365+ children = createRequest(
8366+ children,
8367+ options,
8368+ createRenderState(options, generateStaticMarkup),
8369+ createFormatContext(ROOT_HTML_MODE, null, 0, null),
8370+ Infinity,
8371+ onError,
8372+ void 0,
8373+ function () {
8374+ readyToStream = !0;
8375+ },
8376+ void 0,
8377+ void 0,
8378+ void 0
8379+ );
8380+ startWork(children);
8381+ abort(children, abortReason);
8382+ startFlowing(children, {
8383+ push: function (chunk) {
8384+ null !== chunk && (result += chunk);
8385+ return !0;
8386+ },
8387+ destroy: function (error) {
8388+ didFatal = !0;
8389+ fatalError = error;
8390+ }
8391+ });
8392+ if (didFatal && fatalError !== abortReason) throw fatalError;
8393+ if (!readyToStream)
8394+ throw Error(
8395+ "A component suspended while responding to synchronous input. This will cause the UI to be replaced with a loading indicator. To fix, updates that suspend should be wrapped with startTransition."
8396+ );
8397+ return result;
8398+ }
8399+ var React = require("react"),
8400+ ReactDOM = require("react-dom"),
8401+ REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
8402+ REACT_PORTAL_TYPE = Symbol.for("react.portal"),
8403+ REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
8404+ REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
8405+ REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
8406+ REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
8407+ REACT_CONTEXT_TYPE = Symbol.for("react.context"),
8408+ REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
8409+ REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
8410+ REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
8411+ REACT_MEMO_TYPE = Symbol.for("react.memo"),
8412+ REACT_LAZY_TYPE = Symbol.for("react.lazy"),
8413+ REACT_SCOPE_TYPE = Symbol.for("react.scope"),
8414+ REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
8415+ REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"),
8416+ REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"),
8417+ REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
8418+ MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
8419+ isArrayImpl = Array.isArray,
8420+ jsxPropsParents = new WeakMap(),
8421+ jsxChildrenParents = new WeakMap(),
8422+ CLIENT_REFERENCE_TAG = Symbol.for("react.client.reference"),
8423+ assign = Object.assign,
8424+ hasOwnProperty = Object.prototype.hasOwnProperty,
8425+ VALID_ATTRIBUTE_NAME_REGEX = RegExp(
8426+ "^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
8427+ ),
8428+ illegalAttributeNameCache = {},
8429+ validatedAttributeNameCache = {},
8430+ unitlessNumbers = new Set(
8431+ "animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(
8432+ " "
8433+ )
8434+ ),
8435+ aliases = new Map([
8436+ ["acceptCharset", "accept-charset"],
8437+ ["htmlFor", "for"],
8438+ ["httpEquiv", "http-equiv"],
8439+ ["crossOrigin", "crossorigin"],
8440+ ["accentHeight", "accent-height"],
8441+ ["alignmentBaseline", "alignment-baseline"],
8442+ ["arabicForm", "arabic-form"],
8443+ ["baselineShift", "baseline-shift"],
8444+ ["capHeight", "cap-height"],
8445+ ["clipPath", "clip-path"],
8446+ ["clipRule", "clip-rule"],
8447+ ["colorInterpolation", "color-interpolation"],
8448+ ["colorInterpolationFilters", "color-interpolation-filters"],
8449+ ["colorProfile", "color-profile"],
8450+ ["colorRendering", "color-rendering"],
8451+ ["dominantBaseline", "dominant-baseline"],
8452+ ["enableBackground", "enable-background"],
8453+ ["fillOpacity", "fill-opacity"],
8454+ ["fillRule", "fill-rule"],
8455+ ["floodColor", "flood-color"],
8456+ ["floodOpacity", "flood-opacity"],
8457+ ["fontFamily", "font-family"],
8458+ ["fontSize", "font-size"],
8459+ ["fontSizeAdjust", "font-size-adjust"],
8460+ ["fontStretch", "font-stretch"],
8461+ ["fontStyle", "font-style"],
8462+ ["fontVariant", "font-variant"],
8463+ ["fontWeight", "font-weight"],
8464+ ["glyphName", "glyph-name"],
8465+ ["glyphOrientationHorizontal", "glyph-orientation-horizontal"],
8466+ ["glyphOrientationVertical", "glyph-orientation-vertical"],
8467+ ["horizAdvX", "horiz-adv-x"],
8468+ ["horizOriginX", "horiz-origin-x"],
8469+ ["imageRendering", "image-rendering"],
8470+ ["letterSpacing", "letter-spacing"],
8471+ ["lightingColor", "lighting-color"],
8472+ ["markerEnd", "marker-end"],
8473+ ["markerMid", "marker-mid"],
8474+ ["markerStart", "marker-start"],
8475+ ["overlinePosition", "overline-position"],
8476+ ["overlineThickness", "overline-thickness"],
8477+ ["paintOrder", "paint-order"],
8478+ ["panose-1", "panose-1"],
8479+ ["pointerEvents", "pointer-events"],
8480+ ["renderingIntent", "rendering-intent"],
8481+ ["shapeRendering", "shape-rendering"],
8482+ ["stopColor", "stop-color"],
8483+ ["stopOpacity", "stop-opacity"],
8484+ ["strikethroughPosition", "strikethrough-position"],
8485+ ["strikethroughThickness", "strikethrough-thickness"],
8486+ ["strokeDasharray", "stroke-dasharray"],
8487+ ["strokeDashoffset", "stroke-dashoffset"],
8488+ ["strokeLinecap", "stroke-linecap"],
8489+ ["strokeLinejoin", "stroke-linejoin"],
8490+ ["strokeMiterlimit", "stroke-miterlimit"],
8491+ ["strokeOpacity", "stroke-opacity"],
8492+ ["strokeWidth", "stroke-width"],
8493+ ["textAnchor", "text-anchor"],
8494+ ["textDecoration", "text-decoration"],
8495+ ["textRendering", "text-rendering"],
8496+ ["transformOrigin", "transform-origin"],
8497+ ["underlinePosition", "underline-position"],
8498+ ["underlineThickness", "underline-thickness"],
8499+ ["unicodeBidi", "unicode-bidi"],
8500+ ["unicodeRange", "unicode-range"],
8501+ ["unitsPerEm", "units-per-em"],
8502+ ["vAlphabetic", "v-alphabetic"],
8503+ ["vHanging", "v-hanging"],
8504+ ["vIdeographic", "v-ideographic"],
8505+ ["vMathematical", "v-mathematical"],
8506+ ["vectorEffect", "vector-effect"],
8507+ ["vertAdvY", "vert-adv-y"],
8508+ ["vertOriginX", "vert-origin-x"],
8509+ ["vertOriginY", "vert-origin-y"],
8510+ ["wordSpacing", "word-spacing"],
8511+ ["writingMode", "writing-mode"],
8512+ ["xmlnsXlink", "xmlns:xlink"],
8513+ ["xHeight", "x-height"]
8514+ ]),
8515+ hasReadOnlyValue = {
8516+ button: !0,
8517+ checkbox: !0,
8518+ image: !0,
8519+ hidden: !0,
8520+ radio: !0,
8521+ reset: !0,
8522+ submit: !0
8523+ },
8524+ ariaProperties = {
8525+ "aria-current": 0,
8526+ "aria-description": 0,
8527+ "aria-details": 0,
8528+ "aria-disabled": 0,
8529+ "aria-hidden": 0,
8530+ "aria-invalid": 0,
8531+ "aria-keyshortcuts": 0,
8532+ "aria-label": 0,
8533+ "aria-roledescription": 0,
8534+ "aria-autocomplete": 0,
8535+ "aria-checked": 0,
8536+ "aria-expanded": 0,
8537+ "aria-haspopup": 0,
8538+ "aria-level": 0,
8539+ "aria-modal": 0,
8540+ "aria-multiline": 0,
8541+ "aria-multiselectable": 0,
8542+ "aria-orientation": 0,
8543+ "aria-placeholder": 0,
8544+ "aria-pressed": 0,
8545+ "aria-readonly": 0,
8546+ "aria-required": 0,
8547+ "aria-selected": 0,
8548+ "aria-sort": 0,
8549+ "aria-valuemax": 0,
8550+ "aria-valuemin": 0,
8551+ "aria-valuenow": 0,
8552+ "aria-valuetext": 0,
8553+ "aria-atomic": 0,
8554+ "aria-busy": 0,
8555+ "aria-live": 0,
8556+ "aria-relevant": 0,
8557+ "aria-dropeffect": 0,
8558+ "aria-grabbed": 0,
8559+ "aria-activedescendant": 0,
8560+ "aria-colcount": 0,
8561+ "aria-colindex": 0,
8562+ "aria-colspan": 0,
8563+ "aria-controls": 0,
8564+ "aria-describedby": 0,
8565+ "aria-errormessage": 0,
8566+ "aria-flowto": 0,
8567+ "aria-labelledby": 0,
8568+ "aria-owns": 0,
8569+ "aria-posinset": 0,
8570+ "aria-rowcount": 0,
8571+ "aria-rowindex": 0,
8572+ "aria-rowspan": 0,
8573+ "aria-setsize": 0,
8574+ "aria-braillelabel": 0,
8575+ "aria-brailleroledescription": 0,
8576+ "aria-colindextext": 0,
8577+ "aria-rowindextext": 0
8578+ },
8579+ warnedProperties$1 = {},
8580+ rARIA$1 = RegExp(
8581+ "^(aria)-[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
8582+ ),
8583+ rARIACamel$1 = RegExp(
8584+ "^(aria)[A-Z][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
8585+ ),
8586+ didWarnValueNull = !1,
8587+ possibleStandardNames = {
8588+ accept: "accept",
8589+ acceptcharset: "acceptCharset",
8590+ "accept-charset": "acceptCharset",
8591+ accesskey: "accessKey",
8592+ action: "action",
8593+ allowfullscreen: "allowFullScreen",
8594+ alt: "alt",
8595+ as: "as",
8596+ async: "async",
8597+ autocapitalize: "autoCapitalize",
8598+ autocomplete: "autoComplete",
8599+ autocorrect: "autoCorrect",
8600+ autofocus: "autoFocus",
8601+ autoplay: "autoPlay",
8602+ autosave: "autoSave",
8603+ capture: "capture",
8604+ cellpadding: "cellPadding",
8605+ cellspacing: "cellSpacing",
8606+ challenge: "challenge",
8607+ charset: "charSet",
8608+ checked: "checked",
8609+ children: "children",
8610+ cite: "cite",
8611+ class: "className",
8612+ classid: "classID",
8613+ classname: "className",
8614+ cols: "cols",
8615+ colspan: "colSpan",
8616+ content: "content",
8617+ contenteditable: "contentEditable",
8618+ contextmenu: "contextMenu",
8619+ controls: "controls",
8620+ controlslist: "controlsList",
8621+ coords: "coords",
8622+ crossorigin: "crossOrigin",
8623+ dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
8624+ data: "data",
8625+ datetime: "dateTime",
8626+ default: "default",
8627+ defaultchecked: "defaultChecked",
8628+ defaultvalue: "defaultValue",
8629+ defer: "defer",
8630+ dir: "dir",
8631+ disabled: "disabled",
8632+ disablepictureinpicture: "disablePictureInPicture",
8633+ disableremoteplayback: "disableRemotePlayback",
8634+ download: "download",
8635+ draggable: "draggable",
8636+ enctype: "encType",
8637+ enterkeyhint: "enterKeyHint",
8638+ fetchpriority: "fetchPriority",
8639+ for: "htmlFor",
8640+ form: "form",
8641+ formmethod: "formMethod",
8642+ formaction: "formAction",
8643+ formenctype: "formEncType",
8644+ formnovalidate: "formNoValidate",
8645+ formtarget: "formTarget",
8646+ frameborder: "frameBorder",
8647+ headers: "headers",
8648+ height: "height",
8649+ hidden: "hidden",
8650+ high: "high",
8651+ href: "href",
8652+ hreflang: "hrefLang",
8653+ htmlfor: "htmlFor",
8654+ httpequiv: "httpEquiv",
8655+ "http-equiv": "httpEquiv",
8656+ icon: "icon",
8657+ id: "id",
8658+ imagesizes: "imageSizes",
8659+ imagesrcset: "imageSrcSet",
8660+ inert: "inert",
8661+ innerhtml: "innerHTML",
8662+ inputmode: "inputMode",
8663+ integrity: "integrity",
8664+ is: "is",
8665+ itemid: "itemID",
8666+ itemprop: "itemProp",
8667+ itemref: "itemRef",
8668+ itemscope: "itemScope",
8669+ itemtype: "itemType",
8670+ keyparams: "keyParams",
8671+ keytype: "keyType",
8672+ kind: "kind",
8673+ label: "label",
8674+ lang: "lang",
8675+ list: "list",
8676+ loop: "loop",
8677+ low: "low",
8678+ manifest: "manifest",
8679+ marginwidth: "marginWidth",
8680+ marginheight: "marginHeight",
8681+ max: "max",
8682+ maxlength: "maxLength",
8683+ media: "media",
8684+ mediagroup: "mediaGroup",
8685+ method: "method",
8686+ min: "min",
8687+ minlength: "minLength",
8688+ multiple: "multiple",
8689+ muted: "muted",
8690+ name: "name",
8691+ nomodule: "noModule",
8692+ nonce: "nonce",
8693+ novalidate: "noValidate",
8694+ open: "open",
8695+ optimum: "optimum",
8696+ pattern: "pattern",
8697+ placeholder: "placeholder",
8698+ playsinline: "playsInline",
8699+ poster: "poster",
8700+ preload: "preload",
8701+ profile: "profile",
8702+ radiogroup: "radioGroup",
8703+ readonly: "readOnly",
8704+ referrerpolicy: "referrerPolicy",
8705+ rel: "rel",
8706+ required: "required",
8707+ reversed: "reversed",
8708+ role: "role",
8709+ rows: "rows",
8710+ rowspan: "rowSpan",
8711+ sandbox: "sandbox",
8712+ scope: "scope",
8713+ scoped: "scoped",
8714+ scrolling: "scrolling",
8715+ seamless: "seamless",
8716+ selected: "selected",
8717+ shape: "shape",
8718+ size: "size",
8719+ sizes: "sizes",
8720+ span: "span",
8721+ spellcheck: "spellCheck",
8722+ src: "src",
8723+ srcdoc: "srcDoc",
8724+ srclang: "srcLang",
8725+ srcset: "srcSet",
8726+ start: "start",
8727+ step: "step",
8728+ style: "style",
8729+ summary: "summary",
8730+ tabindex: "tabIndex",
8731+ target: "target",
8732+ title: "title",
8733+ type: "type",
8734+ usemap: "useMap",
8735+ value: "value",
8736+ width: "width",
8737+ wmode: "wmode",
8738+ wrap: "wrap",
8739+ about: "about",
8740+ accentheight: "accentHeight",
8741+ "accent-height": "accentHeight",
8742+ accumulate: "accumulate",
8743+ additive: "additive",
8744+ alignmentbaseline: "alignmentBaseline",
8745+ "alignment-baseline": "alignmentBaseline",
8746+ allowreorder: "allowReorder",
8747+ alphabetic: "alphabetic",
8748+ amplitude: "amplitude",
8749+ arabicform: "arabicForm",
8750+ "arabic-form": "arabicForm",
8751+ ascent: "ascent",
8752+ attributename: "attributeName",
8753+ attributetype: "attributeType",
8754+ autoreverse: "autoReverse",
8755+ azimuth: "azimuth",
8756+ basefrequency: "baseFrequency",
8757+ baselineshift: "baselineShift",
8758+ "baseline-shift": "baselineShift",
8759+ baseprofile: "baseProfile",
8760+ bbox: "bbox",
8761+ begin: "begin",
8762+ bias: "bias",
8763+ by: "by",
8764+ calcmode: "calcMode",
8765+ capheight: "capHeight",
8766+ "cap-height": "capHeight",
8767+ clip: "clip",
8768+ clippath: "clipPath",
8769+ "clip-path": "clipPath",
8770+ clippathunits: "clipPathUnits",
8771+ cliprule: "clipRule",
8772+ "clip-rule": "clipRule",
8773+ color: "color",
8774+ colorinterpolation: "colorInterpolation",
8775+ "color-interpolation": "colorInterpolation",
8776+ colorinterpolationfilters: "colorInterpolationFilters",
8777+ "color-interpolation-filters": "colorInterpolationFilters",
8778+ colorprofile: "colorProfile",
8779+ "color-profile": "colorProfile",
8780+ colorrendering: "colorRendering",
8781+ "color-rendering": "colorRendering",
8782+ contentscripttype: "contentScriptType",
8783+ contentstyletype: "contentStyleType",
8784+ cursor: "cursor",
8785+ cx: "cx",
8786+ cy: "cy",
8787+ d: "d",
8788+ datatype: "datatype",
8789+ decelerate: "decelerate",
8790+ descent: "descent",
8791+ diffuseconstant: "diffuseConstant",
8792+ direction: "direction",
8793+ display: "display",
8794+ divisor: "divisor",
8795+ dominantbaseline: "dominantBaseline",
8796+ "dominant-baseline": "dominantBaseline",
8797+ dur: "dur",
8798+ dx: "dx",
8799+ dy: "dy",
8800+ edgemode: "edgeMode",
8801+ elevation: "elevation",
8802+ enablebackground: "enableBackground",
8803+ "enable-background": "enableBackground",
8804+ end: "end",
8805+ exponent: "exponent",
8806+ externalresourcesrequired: "externalResourcesRequired",
8807+ fill: "fill",
8808+ fillopacity: "fillOpacity",
8809+ "fill-opacity": "fillOpacity",
8810+ fillrule: "fillRule",
8811+ "fill-rule": "fillRule",
8812+ filter: "filter",
8813+ filterres: "filterRes",
8814+ filterunits: "filterUnits",
8815+ floodopacity: "floodOpacity",
8816+ "flood-opacity": "floodOpacity",
8817+ floodcolor: "floodColor",
8818+ "flood-color": "floodColor",
8819+ focusable: "focusable",
8820+ fontfamily: "fontFamily",
8821+ "font-family": "fontFamily",
8822+ fontsize: "fontSize",
8823+ "font-size": "fontSize",
8824+ fontsizeadjust: "fontSizeAdjust",
8825+ "font-size-adjust": "fontSizeAdjust",
8826+ fontstretch: "fontStretch",
8827+ "font-stretch": "fontStretch",
8828+ fontstyle: "fontStyle",
8829+ "font-style": "fontStyle",
8830+ fontvariant: "fontVariant",
8831+ "font-variant": "fontVariant",
8832+ fontweight: "fontWeight",
8833+ "font-weight": "fontWeight",
8834+ format: "format",
8835+ from: "from",
8836+ fx: "fx",
8837+ fy: "fy",
8838+ g1: "g1",
8839+ g2: "g2",
8840+ glyphname: "glyphName",
8841+ "glyph-name": "glyphName",
8842+ glyphorientationhorizontal: "glyphOrientationHorizontal",
8843+ "glyph-orientation-horizontal": "glyphOrientationHorizontal",
8844+ glyphorientationvertical: "glyphOrientationVertical",
8845+ "glyph-orientation-vertical": "glyphOrientationVertical",
8846+ glyphref: "glyphRef",
8847+ gradienttransform: "gradientTransform",
8848+ gradientunits: "gradientUnits",
8849+ hanging: "hanging",
8850+ horizadvx: "horizAdvX",
8851+ "horiz-adv-x": "horizAdvX",
8852+ horizoriginx: "horizOriginX",
8853+ "horiz-origin-x": "horizOriginX",
8854+ ideographic: "ideographic",
8855+ imagerendering: "imageRendering",
8856+ "image-rendering": "imageRendering",
8857+ in2: "in2",
8858+ in: "in",
8859+ inlist: "inlist",
8860+ intercept: "intercept",
8861+ k1: "k1",
8862+ k2: "k2",
8863+ k3: "k3",
8864+ k4: "k4",
8865+ k: "k",
8866+ kernelmatrix: "kernelMatrix",
8867+ kernelunitlength: "kernelUnitLength",
8868+ kerning: "kerning",
8869+ keypoints: "keyPoints",
8870+ keysplines: "keySplines",
8871+ keytimes: "keyTimes",
8872+ lengthadjust: "lengthAdjust",
8873+ letterspacing: "letterSpacing",
8874+ "letter-spacing": "letterSpacing",
8875+ lightingcolor: "lightingColor",
8876+ "lighting-color": "lightingColor",
8877+ limitingconeangle: "limitingConeAngle",
8878+ local: "local",
8879+ markerend: "markerEnd",
8880+ "marker-end": "markerEnd",
8881+ markerheight: "markerHeight",
8882+ markermid: "markerMid",
8883+ "marker-mid": "markerMid",
8884+ markerstart: "markerStart",
8885+ "marker-start": "markerStart",
8886+ markerunits: "markerUnits",
8887+ markerwidth: "markerWidth",
8888+ mask: "mask",
8889+ maskcontentunits: "maskContentUnits",
8890+ maskunits: "maskUnits",
8891+ mathematical: "mathematical",
8892+ mode: "mode",
8893+ numoctaves: "numOctaves",
8894+ offset: "offset",
8895+ opacity: "opacity",
8896+ operator: "operator",
8897+ order: "order",
8898+ orient: "orient",
8899+ orientation: "orientation",
8900+ origin: "origin",
8901+ overflow: "overflow",
8902+ overlineposition: "overlinePosition",
8903+ "overline-position": "overlinePosition",
8904+ overlinethickness: "overlineThickness",
8905+ "overline-thickness": "overlineThickness",
8906+ paintorder: "paintOrder",
8907+ "paint-order": "paintOrder",
8908+ panose1: "panose1",
8909+ "panose-1": "panose1",
8910+ pathlength: "pathLength",
8911+ patterncontentunits: "patternContentUnits",
8912+ patterntransform: "patternTransform",
8913+ patternunits: "patternUnits",
8914+ pointerevents: "pointerEvents",
8915+ "pointer-events": "pointerEvents",
8916+ points: "points",
8917+ pointsatx: "pointsAtX",
8918+ pointsaty: "pointsAtY",
8919+ pointsatz: "pointsAtZ",
8920+ popover: "popover",
8921+ popovertarget: "popoverTarget",
8922+ popovertargetaction: "popoverTargetAction",
8923+ prefix: "prefix",
8924+ preservealpha: "preserveAlpha",
8925+ preserveaspectratio: "preserveAspectRatio",
8926+ primitiveunits: "primitiveUnits",
8927+ property: "property",
8928+ r: "r",
8929+ radius: "radius",
8930+ refx: "refX",
8931+ refy: "refY",
8932+ renderingintent: "renderingIntent",
8933+ "rendering-intent": "renderingIntent",
8934+ repeatcount: "repeatCount",
8935+ repeatdur: "repeatDur",
8936+ requiredextensions: "requiredExtensions",
8937+ requiredfeatures: "requiredFeatures",
8938+ resource: "resource",
8939+ restart: "restart",
8940+ result: "result",
8941+ results: "results",
8942+ rotate: "rotate",
8943+ rx: "rx",
8944+ ry: "ry",
8945+ scale: "scale",
8946+ security: "security",
8947+ seed: "seed",
8948+ shaperendering: "shapeRendering",
8949+ "shape-rendering": "shapeRendering",
8950+ slope: "slope",
8951+ spacing: "spacing",
8952+ specularconstant: "specularConstant",
8953+ specularexponent: "specularExponent",
8954+ speed: "speed",
8955+ spreadmethod: "spreadMethod",
8956+ startoffset: "startOffset",
8957+ stddeviation: "stdDeviation",
8958+ stemh: "stemh",
8959+ stemv: "stemv",
8960+ stitchtiles: "stitchTiles",
8961+ stopcolor: "stopColor",
8962+ "stop-color": "stopColor",
8963+ stopopacity: "stopOpacity",
8964+ "stop-opacity": "stopOpacity",
8965+ strikethroughposition: "strikethroughPosition",
8966+ "strikethrough-position": "strikethroughPosition",
8967+ strikethroughthickness: "strikethroughThickness",
8968+ "strikethrough-thickness": "strikethroughThickness",
8969+ string: "string",
8970+ stroke: "stroke",
8971+ strokedasharray: "strokeDasharray",
8972+ "stroke-dasharray": "strokeDasharray",
8973+ strokedashoffset: "strokeDashoffset",
8974+ "stroke-dashoffset": "strokeDashoffset",
8975+ strokelinecap: "strokeLinecap",
8976+ "stroke-linecap": "strokeLinecap",
8977+ strokelinejoin: "strokeLinejoin",
8978+ "stroke-linejoin": "strokeLinejoin",
8979+ strokemiterlimit: "strokeMiterlimit",
8980+ "stroke-miterlimit": "strokeMiterlimit",
8981+ strokewidth: "strokeWidth",
8982+ "stroke-width": "strokeWidth",
8983+ strokeopacity: "strokeOpacity",
8984+ "stroke-opacity": "strokeOpacity",
8985+ suppresscontenteditablewarning: "suppressContentEditableWarning",
8986+ suppresshydrationwarning: "suppressHydrationWarning",
8987+ surfacescale: "surfaceScale",
8988+ systemlanguage: "systemLanguage",
8989+ tablevalues: "tableValues",
8990+ targetx: "targetX",
8991+ targety: "targetY",
8992+ textanchor: "textAnchor",
8993+ "text-anchor": "textAnchor",
8994+ textdecoration: "textDecoration",
8995+ "text-decoration": "textDecoration",
8996+ textlength: "textLength",
8997+ textrendering: "textRendering",
8998+ "text-rendering": "textRendering",
8999+ to: "to",
9000+ transform: "transform",
9001+ transformorigin: "transformOrigin",
9002+ "transform-origin": "transformOrigin",
9003+ typeof: "typeof",
9004+ u1: "u1",
9005+ u2: "u2",
9006+ underlineposition: "underlinePosition",
9007+ "underline-position": "underlinePosition",
9008+ underlinethickness: "underlineThickness",
9009+ "underline-thickness": "underlineThickness",
9010+ unicode: "unicode",
9011+ unicodebidi: "unicodeBidi",
9012+ "unicode-bidi": "unicodeBidi",
9013+ unicoderange: "unicodeRange",
9014+ "unicode-range": "unicodeRange",
9015+ unitsperem: "unitsPerEm",
9016+ "units-per-em": "unitsPerEm",
9017+ unselectable: "unselectable",
9018+ valphabetic: "vAlphabetic",
9019+ "v-alphabetic": "vAlphabetic",
9020+ values: "values",
9021+ vectoreffect: "vectorEffect",
9022+ "vector-effect": "vectorEffect",
9023+ version: "version",
9024+ vertadvy: "vertAdvY",
9025+ "vert-adv-y": "vertAdvY",
9026+ vertoriginx: "vertOriginX",
9027+ "vert-origin-x": "vertOriginX",
9028+ vertoriginy: "vertOriginY",
9029+ "vert-origin-y": "vertOriginY",
9030+ vhanging: "vHanging",
9031+ "v-hanging": "vHanging",
9032+ videographic: "vIdeographic",
9033+ "v-ideographic": "vIdeographic",
9034+ viewbox: "viewBox",
9035+ viewtarget: "viewTarget",
9036+ visibility: "visibility",
9037+ vmathematical: "vMathematical",
9038+ "v-mathematical": "vMathematical",
9039+ vocab: "vocab",
9040+ widths: "widths",
9041+ wordspacing: "wordSpacing",
9042+ "word-spacing": "wordSpacing",
9043+ writingmode: "writingMode",
9044+ "writing-mode": "writingMode",
9045+ x1: "x1",
9046+ x2: "x2",
9047+ x: "x",
9048+ xchannelselector: "xChannelSelector",
9049+ xheight: "xHeight",
9050+ "x-height": "xHeight",
9051+ xlinkactuate: "xlinkActuate",
9052+ "xlink:actuate": "xlinkActuate",
9053+ xlinkarcrole: "xlinkArcrole",
9054+ "xlink:arcrole": "xlinkArcrole",
9055+ xlinkhref: "xlinkHref",
9056+ "xlink:href": "xlinkHref",
9057+ xlinkrole: "xlinkRole",
9058+ "xlink:role": "xlinkRole",
9059+ xlinkshow: "xlinkShow",
9060+ "xlink:show": "xlinkShow",
9061+ xlinktitle: "xlinkTitle",
9062+ "xlink:title": "xlinkTitle",
9063+ xlinktype: "xlinkType",
9064+ "xlink:type": "xlinkType",
9065+ xmlbase: "xmlBase",
9066+ "xml:base": "xmlBase",
9067+ xmllang: "xmlLang",
9068+ "xml:lang": "xmlLang",
9069+ xmlns: "xmlns",
9070+ "xml:space": "xmlSpace",
9071+ xmlnsxlink: "xmlnsXlink",
9072+ "xmlns:xlink": "xmlnsXlink",
9073+ xmlspace: "xmlSpace",
9074+ y1: "y1",
9075+ y2: "y2",
9076+ y: "y",
9077+ ychannelselector: "yChannelSelector",
9078+ z: "z",
9079+ zoomandpan: "zoomAndPan"
9080+ },
9081+ warnedProperties = {},
9082+ EVENT_NAME_REGEX = /^on./,
9083+ INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/,
9084+ rARIA = RegExp(
9085+ "^(aria)-[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
9086+ ),
9087+ rARIACamel = RegExp(
9088+ "^(aria)[A-Z][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
9089+ ),
9090+ badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/,
9091+ msPattern$1 = /^-ms-/,
9092+ hyphenPattern = /-(.)/g,
9093+ badStyleValueWithSemicolonPattern = /;\s*$/,
9094+ warnedStyleNames = {},
9095+ warnedStyleValues = {},
9096+ warnedForNaNValue = !1,
9097+ warnedForInfinityValue = !1,
9098+ matchHtmlRegExp = /["'&<>]/,
9099+ uppercasePattern = /([A-Z])/g,
9100+ msPattern = /^ms-/,
9101+ isJavaScriptProtocol =
9102+ /^[\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,
9103+ ReactSharedInternals =
9104+ React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
9105+ ReactDOMSharedInternals =
9106+ ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
9107+ NotPending = Object.freeze({
9108+ pending: !1,
9109+ data: null,
9110+ method: null,
9111+ action: null
9112+ }),
9113+ previousDispatcher = ReactDOMSharedInternals.d;
9114+ ReactDOMSharedInternals.d = {
9115+ f: previousDispatcher.f,
9116+ r: previousDispatcher.r,
9117+ D: function (href) {
9118+ var request = currentRequest ? currentRequest : null;
9119+ if (request) {
9120+ var resumableState = request.resumableState,
9121+ renderState = request.renderState;
9122+ if ("string" === typeof href && href) {
9123+ if (!resumableState.dnsResources.hasOwnProperty(href)) {
9124+ resumableState.dnsResources[href] = EXISTS;
9125+ resumableState = renderState.headers;
9126+ var header, JSCompiler_temp;
9127+ if (
9128+ (JSCompiler_temp =
9129+ resumableState && 0 < resumableState.remainingCapacity)
9130+ )
9131+ JSCompiler_temp =
9132+ ((header =
9133+ "<" +
9134+ escapeHrefForLinkHeaderURLContext(href) +
9135+ ">; rel=dns-prefetch"),
9136+ 0 <= (resumableState.remainingCapacity -= header.length + 2));
9137+ JSCompiler_temp
9138+ ? ((renderState.resets.dns[href] = EXISTS),
9139+ resumableState.preconnects &&
9140+ (resumableState.preconnects += ", "),
9141+ (resumableState.preconnects += header))
9142+ : ((header = []),
9143+ pushLinkImpl(header, { href: href, rel: "dns-prefetch" }),
9144+ renderState.preconnects.add(header));
9145+ }
9146+ enqueueFlush(request);
69039147 }
6904− } // We're done.
6905−
6906−
6907− close(destination);
6908− }
6909− }
6910−}
6911−
6912−function startWork(request) {
6913− scheduleWork(function () {
6914− return performWork(request);
6915− });
6916−}
6917−function startFlowing(request, destination) {
6918− if (request.status === CLOSING) {
6919− request.status = CLOSED;
6920− closeWithError(destination, request.fatalError);
6921− return;
6922− }
6923−
6924− if (request.status === CLOSED) {
6925− return;
6926− }
6927−
6928− if (request.destination !== null) {
6929− // We're already flowing.
6930− return;
6931− }
6932−
6933− request.destination = destination;
6934−
6935− try {
6936− flushCompletedQueues(request, destination);
6937− } catch (error) {
6938− logRecoverableError(request, error);
6939− fatalError(request, error);
6940− }
6941−} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
6942−
6943−function abort(request, reason) {
6944− try {
6945− var abortableTasks = request.abortableTasks;
6946− abortableTasks.forEach(function (task) {
6947− return abortTask(task, request, reason);
6948− });
6949− abortableTasks.clear();
6950−
6951− if (request.destination !== null) {
6952− flushCompletedQueues(request, request.destination);
6953− }
6954− } catch (error) {
6955− logRecoverableError(request, error);
6956− fatalError(request, error);
6957− }
6958−}
6959−
6960−function onError() {// Non-fatal errors are ignored.
6961−}
6962−
6963−function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
6964− var didFatal = false;
6965− var fatalError = null;
6966− var result = '';
6967− var destination = {
6968− push: function (chunk) {
6969− if (chunk !== null) {
6970− result += chunk;
9148+ } else previousDispatcher.D(href);
9149+ },
9150+ C: function (href, crossOrigin) {
9151+ var request = currentRequest ? currentRequest : null;
9152+ if (request) {
9153+ var resumableState = request.resumableState,
9154+ renderState = request.renderState;
9155+ if ("string" === typeof href && href) {
9156+ var bucket =
9157+ "use-credentials" === crossOrigin
9158+ ? "credentials"
9159+ : "string" === typeof crossOrigin
9160+ ? "anonymous"
9161+ : "default";
9162+ if (!resumableState.connectResources[bucket].hasOwnProperty(href)) {
9163+ resumableState.connectResources[bucket][href] = EXISTS;
9164+ resumableState = renderState.headers;
9165+ var header, JSCompiler_temp;
9166+ if (
9167+ (JSCompiler_temp =
9168+ resumableState && 0 < resumableState.remainingCapacity)
9169+ ) {
9170+ JSCompiler_temp =
9171+ "<" +
9172+ escapeHrefForLinkHeaderURLContext(href) +
9173+ ">; rel=preconnect";
9174+ if ("string" === typeof crossOrigin) {
9175+ var escapedCrossOrigin =
9176+ escapeStringForLinkHeaderQuotedParamValueContext(
9177+ crossOrigin,
9178+ "crossOrigin"
9179+ );
9180+ JSCompiler_temp +=
9181+ '; crossorigin="' + escapedCrossOrigin + '"';
9182+ }
9183+ JSCompiler_temp =
9184+ ((header = JSCompiler_temp),
9185+ 0 <= (resumableState.remainingCapacity -= header.length + 2));
9186+ }
9187+ JSCompiler_temp
9188+ ? ((renderState.resets.connect[bucket][href] = EXISTS),
9189+ resumableState.preconnects &&
9190+ (resumableState.preconnects += ", "),
9191+ (resumableState.preconnects += header))
9192+ : ((bucket = []),
9193+ pushLinkImpl(bucket, {
9194+ rel: "preconnect",
9195+ href: href,
9196+ crossOrigin: crossOrigin
9197+ }),
9198+ renderState.preconnects.add(bucket));
9199+ }
9200+ enqueueFlush(request);
9201+ }
9202+ } else previousDispatcher.C(href, crossOrigin);
9203+ },
9204+ L: function (href, as, options) {
9205+ var request = currentRequest ? currentRequest : null;
9206+ if (request) {
9207+ var resumableState = request.resumableState,
9208+ renderState = request.renderState;
9209+ if (as && href) {
9210+ switch (as) {
9211+ case "image":
9212+ if (options) {
9213+ var imageSrcSet = options.imageSrcSet;
9214+ var imageSizes = options.imageSizes;
9215+ var fetchPriority = options.fetchPriority;
9216+ }
9217+ var key = imageSrcSet
9218+ ? imageSrcSet + "\n" + (imageSizes || "")
9219+ : href;
9220+ if (resumableState.imageResources.hasOwnProperty(key)) return;
9221+ resumableState.imageResources[key] = PRELOAD_NO_CREDS;
9222+ resumableState = renderState.headers;
9223+ var header;
9224+ resumableState &&
9225+ 0 < resumableState.remainingCapacity &&
9226+ "string" !== typeof imageSrcSet &&
9227+ "high" === fetchPriority &&
9228+ ((header = getPreloadAsHeader(href, as, options)),
9229+ 0 <= (resumableState.remainingCapacity -= header.length + 2))
9230+ ? ((renderState.resets.image[key] = PRELOAD_NO_CREDS),
9231+ resumableState.highImagePreloads &&
9232+ (resumableState.highImagePreloads += ", "),
9233+ (resumableState.highImagePreloads += header))
9234+ : ((resumableState = []),
9235+ pushLinkImpl(
9236+ resumableState,
9237+ assign(
9238+ {
9239+ rel: "preload",
9240+ href: imageSrcSet ? void 0 : href,
9241+ as: as
9242+ },
9243+ options
9244+ )
9245+ ),
9246+ "high" === fetchPriority
9247+ ? renderState.highImagePreloads.add(resumableState)
9248+ : (renderState.bulkPreloads.add(resumableState),
9249+ renderState.preloads.images.set(key, resumableState)));
9250+ break;
9251+ case "style":
9252+ if (resumableState.styleResources.hasOwnProperty(href)) return;
9253+ imageSrcSet = [];
9254+ pushLinkImpl(
9255+ imageSrcSet,
9256+ assign({ rel: "preload", href: href, as: as }, options)
9257+ );
9258+ resumableState.styleResources[href] =
9259+ !options ||
9260+ ("string" !== typeof options.crossOrigin &&
9261+ "string" !== typeof options.integrity)
9262+ ? PRELOAD_NO_CREDS
9263+ : [options.crossOrigin, options.integrity];
9264+ renderState.preloads.stylesheets.set(href, imageSrcSet);
9265+ renderState.bulkPreloads.add(imageSrcSet);
9266+ break;
9267+ case "script":
9268+ if (resumableState.scriptResources.hasOwnProperty(href)) return;
9269+ imageSrcSet = [];
9270+ renderState.preloads.scripts.set(href, imageSrcSet);
9271+ renderState.bulkPreloads.add(imageSrcSet);
9272+ pushLinkImpl(
9273+ imageSrcSet,
9274+ assign({ rel: "preload", href: href, as: as }, options)
9275+ );
9276+ resumableState.scriptResources[href] =
9277+ !options ||
9278+ ("string" !== typeof options.crossOrigin &&
9279+ "string" !== typeof options.integrity)
9280+ ? PRELOAD_NO_CREDS
9281+ : [options.crossOrigin, options.integrity];
9282+ break;
9283+ default:
9284+ if (resumableState.unknownResources.hasOwnProperty(as)) {
9285+ if (
9286+ ((imageSrcSet = resumableState.unknownResources[as]),
9287+ imageSrcSet.hasOwnProperty(href))
9288+ )
9289+ return;
9290+ } else
9291+ (imageSrcSet = {}),
9292+ (resumableState.unknownResources[as] = imageSrcSet);
9293+ imageSrcSet[href] = PRELOAD_NO_CREDS;
9294+ if (
9295+ (resumableState = renderState.headers) &&
9296+ 0 < resumableState.remainingCapacity &&
9297+ "font" === as &&
9298+ ((key = getPreloadAsHeader(href, as, options)),
9299+ 0 <= (resumableState.remainingCapacity -= key.length + 2))
9300+ )
9301+ (renderState.resets.font[href] = PRELOAD_NO_CREDS),
9302+ resumableState.fontPreloads &&
9303+ (resumableState.fontPreloads += ", "),
9304+ (resumableState.fontPreloads += key);
9305+ else
9306+ switch (
9307+ ((resumableState = []),
9308+ (href = assign(
9309+ { rel: "preload", href: href, as: as },
9310+ options
9311+ )),
9312+ pushLinkImpl(resumableState, href),
9313+ as)
9314+ ) {
9315+ case "font":
9316+ renderState.fontPreloads.add(resumableState);
9317+ break;
9318+ default:
9319+ renderState.bulkPreloads.add(resumableState);
9320+ }
9321+ }
9322+ enqueueFlush(request);
9323+ }
9324+ } else previousDispatcher.L(href, as, options);
9325+ },
9326+ m: function (href, options) {
9327+ var request = currentRequest ? currentRequest : null;
9328+ if (request) {
9329+ var resumableState = request.resumableState,
9330+ renderState = request.renderState;
9331+ if (href) {
9332+ var as =
9333+ options && "string" === typeof options.as ? options.as : "script";
9334+ switch (as) {
9335+ case "script":
9336+ if (resumableState.moduleScriptResources.hasOwnProperty(href))
9337+ return;
9338+ as = [];
9339+ resumableState.moduleScriptResources[href] =
9340+ !options ||
9341+ ("string" !== typeof options.crossOrigin &&
9342+ "string" !== typeof options.integrity)
9343+ ? PRELOAD_NO_CREDS
9344+ : [options.crossOrigin, options.integrity];
9345+ renderState.preloads.moduleScripts.set(href, as);
9346+ break;
9347+ default:
9348+ if (resumableState.moduleUnknownResources.hasOwnProperty(as)) {
9349+ var resources = resumableState.unknownResources[as];
9350+ if (resources.hasOwnProperty(href)) return;
9351+ } else
9352+ (resources = {}),
9353+ (resumableState.moduleUnknownResources[as] = resources);
9354+ as = [];
9355+ resources[href] = PRELOAD_NO_CREDS;
9356+ }
9357+ pushLinkImpl(
9358+ as,
9359+ assign({ rel: "modulepreload", href: href }, options)
9360+ );
9361+ renderState.bulkPreloads.add(as);
9362+ enqueueFlush(request);
9363+ }
9364+ } else previousDispatcher.m(href, options);
9365+ },
9366+ X: function (src, options) {
9367+ var request = currentRequest ? currentRequest : null;
9368+ if (request) {
9369+ var resumableState = request.resumableState,
9370+ renderState = request.renderState;
9371+ if (src) {
9372+ var resourceState = resumableState.scriptResources.hasOwnProperty(
9373+ src
9374+ )
9375+ ? resumableState.scriptResources[src]
9376+ : void 0;
9377+ resourceState !== EXISTS &&
9378+ ((resumableState.scriptResources[src] = EXISTS),
9379+ (options = assign({ src: src, async: !0 }, options)),
9380+ resourceState &&
9381+ (2 === resourceState.length &&
9382+ adoptPreloadCredentials(options, resourceState),
9383+ (src = renderState.preloads.scripts.get(src))) &&
9384+ (src.length = 0),
9385+ (src = []),
9386+ renderState.scripts.add(src),
9387+ pushScriptImpl(src, options),
9388+ enqueueFlush(request));
9389+ }
9390+ } else previousDispatcher.X(src, options);
9391+ },
9392+ S: function (href, precedence, options) {
9393+ var request = currentRequest ? currentRequest : null;
9394+ if (request) {
9395+ var resumableState = request.resumableState,
9396+ renderState = request.renderState;
9397+ if (href) {
9398+ precedence = precedence || "default";
9399+ var styleQueue = renderState.styles.get(precedence),
9400+ resourceState = resumableState.styleResources.hasOwnProperty(href)
9401+ ? resumableState.styleResources[href]
9402+ : void 0;
9403+ resourceState !== EXISTS &&
9404+ ((resumableState.styleResources[href] = EXISTS),
9405+ styleQueue ||
9406+ ((styleQueue = {
9407+ precedence: escapeTextForBrowser(precedence),
9408+ rules: [],
9409+ hrefs: [],
9410+ sheets: new Map()
9411+ }),
9412+ renderState.styles.set(precedence, styleQueue)),
9413+ (precedence = {
9414+ state: PENDING$1,
9415+ props: assign(
9416+ {
9417+ rel: "stylesheet",
9418+ href: href,
9419+ "data-precedence": precedence
9420+ },
9421+ options
9422+ )
9423+ }),
9424+ resourceState &&
9425+ (2 === resourceState.length &&
9426+ adoptPreloadCredentials(precedence.props, resourceState),
9427+ (renderState = renderState.preloads.stylesheets.get(href)) &&
9428+ 0 < renderState.length
9429+ ? (renderState.length = 0)
9430+ : (precedence.state = PRELOADED)),
9431+ styleQueue.sheets.set(href, precedence),
9432+ enqueueFlush(request));
9433+ }
9434+ } else previousDispatcher.S(href, precedence, options);
9435+ },
9436+ M: function (src, options) {
9437+ var request = currentRequest ? currentRequest : null;
9438+ if (request) {
9439+ var resumableState = request.resumableState,
9440+ renderState = request.renderState;
9441+ if (src) {
9442+ var resourceState =
9443+ resumableState.moduleScriptResources.hasOwnProperty(src)
9444+ ? resumableState.moduleScriptResources[src]
9445+ : void 0;
9446+ resourceState !== EXISTS &&
9447+ ((resumableState.moduleScriptResources[src] = EXISTS),
9448+ (options = assign(
9449+ { src: src, type: "module", async: !0 },
9450+ options
9451+ )),
9452+ resourceState &&
9453+ (2 === resourceState.length &&
9454+ adoptPreloadCredentials(options, resourceState),
9455+ (src = renderState.preloads.moduleScripts.get(src))) &&
9456+ (src.length = 0),
9457+ (src = []),
9458+ renderState.scripts.add(src),
9459+ pushScriptImpl(src, options),
9460+ enqueueFlush(request));
9461+ }
9462+ } else previousDispatcher.M(src, options);
69719463 }
6972−
6973− return true;
6974− },
6975− destroy: function (error) {
6976− didFatal = true;
6977− fatalError = error;
6978− }
6979− };
6980− var readyToStream = false;
6981−
6982− function onShellReady() {
6983− readyToStream = true;
6984− }
6985−
6986− var request = createRequest(children, createResponseState$1(generateStaticMarkup, options ? options.identifierPrefix : undefined), createRootFormatContext(), Infinity, onError, undefined, onShellReady, undefined, undefined);
6987− startWork(request); // If anything suspended and is still pending, we'll abort it before writing.
6988− // That way we write only client-rendered boundaries from the start.
6989−
6990− abort(request, abortReason);
6991− startFlowing(request, destination);
6992−
6993− if (didFatal) {
6994− throw fatalError;
6995− }
6996−
6997− if (!readyToStream) {
6998− // Note: This error message is the one we use on the client. It doesn't
6999− // really make sense here. But this is the legacy server renderer, anyway.
7000− // We're going to delete it soon.
7001− throw new Error('A component suspended while responding to synchronous input. This ' + 'will cause the UI to be replaced with a loading indicator. To fix, ' + 'updates that suspend should be wrapped with startTransition.');
7002− }
7003−
7004− return result;
7005−}
7006−
7007−function renderToString(children, options) {
7008− return renderToStringImpl(children, options, false, 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server');
7009−}
7010−
7011−function renderToStaticMarkup(children, options) {
7012− return renderToStringImpl(children, options, true, 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server');
7013−}
7014−
7015−function renderToNodeStream() {
7016− throw new Error('ReactDOMServer.renderToNodeStream(): The streaming API is not available ' + 'in the browser. Use ReactDOMServer.renderToString() instead.');
7017−}
7018−
7019−function renderToStaticNodeStream() {
7020− throw new Error('ReactDOMServer.renderToStaticNodeStream(): The streaming API is not available ' + 'in the browser. Use ReactDOMServer.renderToStaticMarkup() instead.');
7021−}
7022−
7023−exports.renderToNodeStream = renderToNodeStream;
7024−exports.renderToStaticMarkup = renderToStaticMarkup;
7025−exports.renderToStaticNodeStream = renderToStaticNodeStream;
7026−exports.renderToString = renderToString;
7027−exports.version = ReactVersion;
9464+ };
9465+ var NothingSent = 0,
9466+ SentCompleteSegmentFunction = 1,
9467+ SentCompleteBoundaryFunction = 2,
9468+ SentClientRenderFunction = 4,
9469+ SentStyleInsertionFunction = 8,
9470+ SentCompletedShellId = 32,
9471+ SentMarkShellTime = 64,
9472+ EXISTS = null,
9473+ PRELOAD_NO_CREDS = [];
9474+ Object.freeze(PRELOAD_NO_CREDS);
9475+ var currentlyFlushingRenderState = null,
9476+ endInlineScript = "\x3c/script>",
9477+ scriptRegex = /(<\/|<)(s)(cript)/gi;
9478+ var didWarnForNewBooleanPropsWithEmptyValue = {};
9479+ var ROOT_HTML_MODE = 0,
9480+ HTML_HTML_MODE = 1,
9481+ HTML_MODE = 2,
9482+ HTML_HEAD_MODE = 3,
9483+ SVG_MODE = 4,
9484+ MATHML_MODE = 5,
9485+ HTML_TABLE_MODE = 6,
9486+ HTML_TABLE_BODY_MODE = 7,
9487+ HTML_TABLE_ROW_MODE = 8,
9488+ HTML_COLGROUP_MODE = 9,
9489+ styleNameCache = new Map(),
9490+ styleAttributeStart = ' style="',
9491+ styleAssign = ":",
9492+ styleSeparator = ";",
9493+ attributeSeparator = " ",
9494+ attributeAssign = '="',
9495+ attributeEnd = '"',
9496+ attributeEmptyString = '=""',
9497+ actionJavaScriptURL = escapeTextForBrowser(
9498+ "javascript:throw new Error('React form unexpectedly submitted.')"
9499+ ),
9500+ endOfStartTag = ">",
9501+ endOfStartTagSelfClosing = "/>",
9502+ didWarnDefaultInputValue = !1,
9503+ didWarnDefaultChecked = !1,
9504+ didWarnDefaultSelectValue = !1,
9505+ didWarnDefaultTextareaValue = !1,
9506+ didWarnInvalidOptionChildren = !1,
9507+ didWarnInvalidOptionInnerHTML = !1,
9508+ didWarnSelectedSetOnOption = !1,
9509+ didWarnFormActionType = !1,
9510+ didWarnFormActionName = !1,
9511+ didWarnFormActionTarget = !1,
9512+ didWarnFormActionMethod = !1,
9513+ formReplayingRuntimeScript =
9514+ 'addEventListener("submit",function(a){if(!a.defaultPrevented){var c=a.target,d=a.submitter,e=c.action,b=d;if(d){var f=d.getAttribute("formAction");null!=f&&(e=f,b=null)}"javascript:throw new Error(\'React form unexpectedly submitted.\')"===e&&(a.preventDefault(),b?(a=document.createElement("input"),a.name=b.name,a.value=b.value,b.parentNode.insertBefore(a,b),b=new FormData(c),a.parentNode.removeChild(a)):b=new FormData(c),a=c.ownerDocument||c,(a.$$reactFormReplay=a.$$reactFormReplay||[]).push(c,d,b))}});',
9515+ styleRegex = /(<\/|<)(s)(tyle)/gi,
9516+ leadingNewline = "\n",
9517+ VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,
9518+ validatedTagCache = new Map(),
9519+ endTagCache = new Map(),
9520+ shellTimeRuntimeScript =
9521+ "requestAnimationFrame(function(){$RT=performance.now()});",
9522+ placeholder1 = '<template id="',
9523+ placeholder2 = '"></template>',
9524+ startCompletedSuspenseBoundary = "\x3c!--$--\x3e",
9525+ startPendingSuspenseBoundary1 = '\x3c!--$?--\x3e<template id="',
9526+ startPendingSuspenseBoundary2 = '"></template>',
9527+ startClientRenderedSuspenseBoundary = "\x3c!--$!--\x3e",
9528+ endSuspenseBoundary = "\x3c!--/$--\x3e",
9529+ clientRenderedSuspenseBoundaryError1 = "<template",
9530+ clientRenderedSuspenseBoundaryErrorAttrInterstitial = '"',
9531+ clientRenderedSuspenseBoundaryError1A = ' data-dgst="',
9532+ clientRenderedSuspenseBoundaryError1B = ' data-msg="',
9533+ clientRenderedSuspenseBoundaryError1C = ' data-stck="',
9534+ clientRenderedSuspenseBoundaryError1D = ' data-cstck="',
9535+ clientRenderedSuspenseBoundaryError2 = "></template>",
9536+ startSegmentHTML = '<div hidden id="',
9537+ startSegmentHTML2 = '">',
9538+ endSegmentHTML = "</div>",
9539+ startSegmentSVG = '<svg aria-hidden="true" style="display:none" id="',
9540+ startSegmentSVG2 = '">',
9541+ endSegmentSVG = "</svg>",
9542+ startSegmentMathML = '<math aria-hidden="true" style="display:none" id="',
9543+ startSegmentMathML2 = '">',
9544+ endSegmentMathML = "</math>",
9545+ startSegmentTable = '<table hidden id="',
9546+ startSegmentTable2 = '">',
9547+ endSegmentTable = "</table>",
9548+ startSegmentTableBody = '<table hidden><tbody id="',
9549+ startSegmentTableBody2 = '">',
9550+ endSegmentTableBody = "</tbody></table>",
9551+ startSegmentTableRow = '<table hidden><tr id="',
9552+ startSegmentTableRow2 = '">',
9553+ endSegmentTableRow = "</tr></table>",
9554+ startSegmentColGroup = '<table hidden><colgroup id="',
9555+ startSegmentColGroup2 = '">',
9556+ endSegmentColGroup = "</colgroup></table>",
9557+ completeSegmentScript1Full =
9558+ '$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("',
9559+ completeSegmentScript1Partial = '$RS("',
9560+ completeSegmentScript2 = '","',
9561+ completeSegmentScriptEnd = '")\x3c/script>',
9562+ completeBoundaryScriptFunctionOnly =
9563+ '$RB=[];$RV=function(a){$RT=performance.now();for(var b=0;b<a.length;b+=2){var c=a[b],e=a[b+1];null!==e.parentNode&&e.parentNode.removeChild(e);var f=c.parentNode;if(f){var g=c.previousSibling,h=0;do{if(c&&8===c.nodeType){var d=c.data;if("/$"===d||"/&"===d)if(0===h)break;else h--;else"$"!==d&&"$?"!==d&&"$~"!==d&&"$!"!==d&&"&"!==d||h++}d=c.nextSibling;f.removeChild(c);c=d}while(c);for(;e.firstChild;)f.insertBefore(e.firstChild,c);g.data="$";g._reactRetry&&requestAnimationFrame(g._reactRetry)}}a.length=0};\n$RC=function(a,b){if(b=document.getElementById(b))(a=document.getElementById(a))?(a.previousSibling.data="$~",$RB.push(a,b),2===$RB.length&&("number"!==typeof $RT?requestAnimationFrame($RV.bind(null,$RB)):(a=performance.now(),setTimeout($RV.bind(null,$RB),2300>a&&2E3<a?2300-a:$RT+300-a)))):b.parentNode.removeChild(b)};',
9564+ completeBoundaryScript1Partial = '$RC("',
9565+ completeBoundaryWithStylesScript1FullPartial =
9566+ '$RM=new Map;$RR=function(n,w,p){function u(q){this._p=null;q()}for(var r=new Map,t=document,h,b,e=t.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=e[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&$RM.set(b.getAttribute("href"),b),r.set(b.dataset.precedence,h=b));e=0;b=[];var l,a;for(k=!0;;){if(k){var f=p[e++];if(!f){k=!1;e=0;continue}var c=!1,m=0;var d=f[m++];if(a=$RM.get(d)){var g=a._p;c=!0}else{a=t.createElement("link");a.href=d;a.rel=\n"stylesheet";for(a.dataset.precedence=l=f[m++];g=f[m++];)a.setAttribute(g,f[m++]);g=a._p=new Promise(function(q,x){a.onload=u.bind(a,q);a.onerror=u.bind(a,x)});$RM.set(d,a)}d=a.getAttribute("media");!g||d&&!matchMedia(d).matches||b.push(g);if(c)continue}else{a=v[e++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=r.get(l)||h;c===h&&(h=a);r.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=t.head,c.insertBefore(a,c.firstChild))}if(p=document.getElementById(n))p.previousSibling.data=\n"$~";Promise.all(b).then($RC.bind(null,n,w),$RX.bind(null,n,"CSS failed to load"))};$RR("',
9567+ completeBoundaryWithStylesScript1Partial = '$RR("',
9568+ completeBoundaryScript2 = '","',
9569+ completeBoundaryScript3a = '",',
9570+ completeBoundaryScript3b = '"',
9571+ completeBoundaryScriptEnd = ")\x3c/script>",
9572+ clientRenderScriptFunctionOnly =
9573+ '$RX=function(b,c,d,e,f){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),f&&(a.cstck=f),b._reactRetry&&b._reactRetry())};',
9574+ clientRenderScript1Full =
9575+ '$RX=function(b,c,d,e,f){var a=document.getElementById(b);a&&(b=a.previousSibling,b.data="$!",a=a.dataset,c&&(a.dgst=c),d&&(a.msg=d),e&&(a.stck=e),f&&(a.cstck=f),b._reactRetry&&b._reactRetry())};;$RX("',
9576+ clientRenderScript1Partial = '$RX("',
9577+ clientRenderScript1A = '"',
9578+ clientRenderErrorScriptArgInterstitial = ",",
9579+ clientRenderScriptEnd = ")\x3c/script>",
9580+ regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g,
9581+ regexForJSStringsInScripts = /[&><\u2028\u2029]/g,
9582+ lateStyleTagResourceOpen1 = ' media="not all" data-precedence="',
9583+ lateStyleTagResourceOpen2 = '" data-href="',
9584+ lateStyleTagResourceOpen3 = '">',
9585+ lateStyleTagTemplateClose = "</style>",
9586+ currentlyRenderingBoundaryHasStylesToHoist = !1,
9587+ destinationHasCapacity = !0,
9588+ stylesheetFlushingQueue = [],
9589+ styleTagResourceOpen1 = ' data-precedence="',
9590+ styleTagResourceOpen2 = '" data-href="',
9591+ spaceSeparator = " ",
9592+ styleTagResourceOpen3 = '">',
9593+ styleTagResourceClose = "</style>",
9594+ completedShellIdAttributeStart = ' id="',
9595+ arrayFirstOpenBracket = "[",
9596+ arraySubsequentOpenBracket = ",[",
9597+ arrayInterstitial = ",",
9598+ arrayCloseBracket = "]",
9599+ PENDING$1 = 0,
9600+ PRELOADED = 1,
9601+ PREAMBLE = 2,
9602+ LATE = 3,
9603+ regexForHrefInLinkHeaderURLContext = /[<>\r\n]/g,
9604+ regexForLinkHeaderQuotedParamValueContext = /["';,\r\n]/g,
9605+ doctypeChunk = "",
9606+ bind = Function.prototype.bind,
9607+ REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
9608+ emptyContextObject = {};
9609+ Object.freeze(emptyContextObject);
9610+ var rendererSigil = {};
9611+ var currentActiveSnapshot = null,
9612+ didWarnAboutNoopUpdateForComponent = {},
9613+ didWarnAboutDeprecatedWillMount = {};
9614+ var didWarnAboutUninitializedState = new Set();
9615+ var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
9616+ var didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
9617+ var didWarnAboutDirectlyAssigningPropsToState = new Set();
9618+ var didWarnAboutUndefinedDerivedState = new Set();
9619+ var didWarnAboutContextTypes$1 = new Set();
9620+ var didWarnAboutChildContextTypes = new Set();
9621+ var didWarnAboutInvalidateContextType = new Set();
9622+ var didWarnOnInvalidCallback = new Set();
9623+ var classComponentUpdater = {
9624+ enqueueSetState: function (inst, payload, callback) {
9625+ var internals = inst._reactInternals;
9626+ null === internals.queue
9627+ ? warnNoop(inst, "setState")
9628+ : (internals.queue.push(payload),
9629+ void 0 !== callback &&
9630+ null !== callback &&
9631+ warnOnInvalidCallback(callback));
9632+ },
9633+ enqueueReplaceState: function (inst, payload, callback) {
9634+ inst = inst._reactInternals;
9635+ inst.replace = !0;
9636+ inst.queue = [payload];
9637+ void 0 !== callback &&
9638+ null !== callback &&
9639+ warnOnInvalidCallback(callback);
9640+ },
9641+ enqueueForceUpdate: function (inst, callback) {
9642+ null === inst._reactInternals.queue
9643+ ? warnNoop(inst, "forceUpdate")
9644+ : void 0 !== callback &&
9645+ null !== callback &&
9646+ warnOnInvalidCallback(callback);
9647+ }
9648+ },
9649+ emptyTreeContext = { id: 1, overflow: "" },
9650+ clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
9651+ log = Math.log,
9652+ LN2 = Math.LN2,
9653+ SuspenseException = Error(
9654+ "Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`."
9655+ ),
9656+ suspendedThenable = null,
9657+ objectIs = "function" === typeof Object.is ? Object.is : is,
9658+ currentlyRenderingComponent = null,
9659+ currentlyRenderingTask = null,
9660+ currentlyRenderingRequest = null,
9661+ currentlyRenderingKeyPath = null,
9662+ firstWorkInProgressHook = null,
9663+ workInProgressHook = null,
9664+ isReRender = !1,
9665+ didScheduleRenderPhaseUpdate = !1,
9666+ localIdCounter = 0,
9667+ actionStateCounter = 0,
9668+ actionStateMatchingIndex = -1,
9669+ thenableIndexCounter = 0,
9670+ thenableState = null,
9671+ renderPhaseUpdates = null,
9672+ numberOfReRenders = 0,
9673+ isInHookUserCodeInDev = !1,
9674+ currentHookNameInDev,
9675+ HooksDispatcher = {
9676+ readContext: readContext,
9677+ use: function (usable) {
9678+ if (null !== usable && "object" === typeof usable) {
9679+ if ("function" === typeof usable.then)
9680+ return unwrapThenable(usable);
9681+ if (usable.$$typeof === REACT_CONTEXT_TYPE)
9682+ return readContext(usable);
9683+ }
9684+ throw Error(
9685+ "An unsupported type was passed to use(): " + String(usable)
9686+ );
9687+ },
9688+ useContext: function (context) {
9689+ currentHookNameInDev = "useContext";
9690+ resolveCurrentlyRenderingComponent();
9691+ return context._currentValue2;
9692+ },
9693+ useMemo: useMemo,
9694+ useReducer: useReducer,
9695+ useRef: function (initialValue) {
9696+ currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
9697+ workInProgressHook = createWorkInProgressHook();
9698+ var previousRef = workInProgressHook.memoizedState;
9699+ return null === previousRef
9700+ ? ((initialValue = { current: initialValue }),
9701+ Object.seal(initialValue),
9702+ (workInProgressHook.memoizedState = initialValue))
9703+ : previousRef;
9704+ },
9705+ useState: function (initialState) {
9706+ currentHookNameInDev = "useState";
9707+ return useReducer(basicStateReducer, initialState);
9708+ },
9709+ useInsertionEffect: noop,
9710+ useLayoutEffect: noop,
9711+ useCallback: function (callback, deps) {
9712+ return useMemo(function () {
9713+ return callback;
9714+ }, deps);
9715+ },
9716+ useImperativeHandle: noop,
9717+ useEffect: noop,
9718+ useDebugValue: noop,
9719+ useDeferredValue: function (value, initialValue) {
9720+ resolveCurrentlyRenderingComponent();
9721+ return void 0 !== initialValue ? initialValue : value;
9722+ },
9723+ useTransition: function () {
9724+ resolveCurrentlyRenderingComponent();
9725+ return [!1, unsupportedStartTransition];
9726+ },
9727+ useId: function () {
9728+ var treeId = currentlyRenderingTask.treeContext;
9729+ var overflow = treeId.overflow;
9730+ treeId = treeId.id;
9731+ treeId =
9732+ (treeId & ~(1 << (32 - clz32(treeId) - 1))).toString(32) + overflow;
9733+ var resumableState = currentResumableState;
9734+ if (null === resumableState)
9735+ throw Error(
9736+ "Invalid hook call. Hooks can only be called inside of the body of a function component."
9737+ );
9738+ overflow = localIdCounter++;
9739+ treeId = "_" + resumableState.idPrefix + "R_" + treeId;
9740+ 0 < overflow && (treeId += "H" + overflow.toString(32));
9741+ return treeId + "_";
9742+ },
9743+ useSyncExternalStore: function (
9744+ subscribe,
9745+ getSnapshot,
9746+ getServerSnapshot
9747+ ) {
9748+ if (void 0 === getServerSnapshot)
9749+ throw Error(
9750+ "Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering."
9751+ );
9752+ return getServerSnapshot();
9753+ },
9754+ useOptimistic: function (passthrough) {
9755+ resolveCurrentlyRenderingComponent();
9756+ return [passthrough, unsupportedSetOptimisticState];
9757+ },
9758+ useActionState: useActionState,
9759+ useFormState: useActionState,
9760+ useHostTransitionStatus: function () {
9761+ resolveCurrentlyRenderingComponent();
9762+ return NotPending;
9763+ },
9764+ useMemoCache: function (size) {
9765+ for (var data = Array(size), i = 0; i < size; i++)
9766+ data[i] = REACT_MEMO_CACHE_SENTINEL;
9767+ return data;
9768+ },
9769+ useCacheRefresh: function () {
9770+ return unsupportedRefresh;
9771+ },
9772+ useEffectEvent: function () {
9773+ return throwOnUseEffectEventCall;
9774+ }
9775+ },
9776+ currentResumableState = null,
9777+ currentTaskInDEV = null,
9778+ DefaultAsyncDispatcher = {
9779+ getCacheForType: function () {
9780+ throw Error("Not implemented.");
9781+ },
9782+ cacheSignal: function () {
9783+ throw Error("Not implemented.");
9784+ },
9785+ getOwner: function () {
9786+ return null === currentTaskInDEV
9787+ ? null
9788+ : currentTaskInDEV.componentStack;
9789+ }
9790+ },
9791+ disabledDepth = 0,
9792+ prevLog,
9793+ prevInfo,
9794+ prevWarn,
9795+ prevError,
9796+ prevGroup,
9797+ prevGroupCollapsed,
9798+ prevGroupEnd;
9799+ disabledLog.__reactDisabledLog = !0;
9800+ var prefix,
9801+ suffix,
9802+ reentry = !1;
9803+ var componentFrameCache = new (
9804+ "function" === typeof WeakMap ? WeakMap : Map
9805+ )();
9806+ var callComponent = {
9807+ react_stack_bottom_frame: function (Component, props, secondArg) {
9808+ return Component(props, secondArg);
9809+ }
9810+ },
9811+ callComponentInDEV =
9812+ callComponent.react_stack_bottom_frame.bind(callComponent),
9813+ callRender = {
9814+ react_stack_bottom_frame: function (instance) {
9815+ return instance.render();
9816+ }
9817+ },
9818+ callRenderInDEV = callRender.react_stack_bottom_frame.bind(callRender),
9819+ callLazyInit = {
9820+ react_stack_bottom_frame: function (lazy) {
9821+ var init = lazy._init;
9822+ return init(lazy._payload);
9823+ }
9824+ },
9825+ callLazyInitInDEV =
9826+ callLazyInit.react_stack_bottom_frame.bind(callLazyInit),
9827+ lastResetTime = 0;
9828+ if (
9829+ "object" === typeof performance &&
9830+ "function" === typeof performance.now
9831+ ) {
9832+ var localPerformance = performance;
9833+ var getCurrentTime = function () {
9834+ return localPerformance.now();
9835+ };
9836+ } else {
9837+ var localDate = Date;
9838+ getCurrentTime = function () {
9839+ return localDate.now();
9840+ };
9841+ }
9842+ var CLIENT_RENDERED = 4,
9843+ PENDING = 0,
9844+ COMPLETED = 1,
9845+ FLUSHED = 2,
9846+ ABORTED = 3,
9847+ ERRORED = 4,
9848+ POSTPONED = 5,
9849+ CLOSED = 14,
9850+ currentRequest = null,
9851+ didWarnAboutBadClass = {},
9852+ didWarnAboutContextTypes = {},
9853+ didWarnAboutContextTypeOnFunctionComponent = {},
9854+ didWarnAboutGetDerivedStateOnFunctionComponent = {},
9855+ didWarnAboutReassigningProps = !1,
9856+ didWarnAboutGenerators = !1,
9857+ didWarnAboutMaps = !1,
9858+ flushedByteSize = 0,
9859+ flushingPartialBoundaries = !1;
9860+ exports.renderToStaticMarkup = function (children, options) {
9861+ return renderToStringImpl(
9862+ children,
9863+ options,
9864+ !0,
9865+ 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server'
9866+ );
9867+ };
9868+ exports.renderToString = function (children, options) {
9869+ return renderToStringImpl(
9870+ children,
9871+ options,
9872+ !1,
9873+ 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server'
9874+ );
9875+ };
9876+ exports.version = "19.2.4";
70289877 })();
7029−}