diff --git a/package.json b/package.json
index 833ad32c2a592..dc3fd758e4a54 100644
--- a/package.json
+++ b/package.json
@@ -196,10 +196,12 @@
"random-seed": "0.3.0",
"react": "18.2.0",
"react-17": "npm:react@17.0.2",
- "react-builtin": "npm:react@18.3.0-next-1f248bdd7-20230419",
+ "react-builtin": "npm:react@18.3.0-next-c8369527e-20230420",
+ "react-experimental-builtin": "npm:react@0.0.0-experimental-c8369527e-20230420",
"react-dom": "18.2.0",
"react-dom-17": "npm:react-dom@17.0.2",
- "react-dom-builtin": "npm:react-dom@18.3.0-next-1f248bdd7-20230419",
+ "react-dom-builtin": "npm:react-dom@18.3.0-next-c8369527e-20230420",
+ "react-dom-experimental-builtin": "npm:react-dom@0.0.0-experimental-c8369527e-20230420",
"react-server-dom-webpack": "18.3.0-next-1f248bdd7-20230419",
"react-ssr-prepass": "1.0.8",
"react-virtualized": "9.22.3",
@@ -211,6 +213,8 @@
"rimraf": "3.0.2",
"sass": "1.54.0",
"satori": "0.4.4",
+ "scheduler-builtin": "npm:scheduler@0.24.0-next-c8369527e-20230420",
+ "scheduler-experimental-builtin": "npm:scheduler@0.0.0-experimental-c8369527e-20230420",
"seedrandom": "3.0.5",
"selenium-webdriver": "4.0.0-beta.4",
"semver": "7.3.7",
diff --git a/packages/next/src/build/utils.ts b/packages/next/src/build/utils.ts
index eb625f3fcc358..e74266ca8d870 100644
--- a/packages/next/src/build/utils.ts
+++ b/packages/next/src/build/utils.ts
@@ -1943,6 +1943,25 @@ if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
let handler
+const currentPort = parseInt(process.env.PORT, 10) || 3000
+const hostname = process.env.HOSTNAME || 'localhost'
+const keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
+const nextConfig = ${JSON.stringify({
+ ...serverConfig,
+ distDir: `./${path.relative(dir, distDir)}`,
+ })}
+
+${
+ // In standalone mode, we don't have separated render workers so if both
+ // app and pages are used, we need to resolve to the prebundled React
+ // to ensure the correctness of the version for app.
+ `\
+if (nextConfig && nextConfig.experimental && nextConfig.experimental.appDir) {
+ process.env.__NEXT_PRIVATE_PREBUNDLED_REACT = '1'
+}
+`
+}
+
const server = http.createServer(async (req, res) => {
try {
await handler(req, res)
@@ -1952,9 +1971,6 @@ const server = http.createServer(async (req, res) => {
res.end('internal server error')
}
})
-const currentPort = parseInt(process.env.PORT, 10) || 3000
-const hostname = process.env.HOSTNAME || 'localhost'
-const keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
if (
!Number.isNaN(keepAliveTimeout) &&
@@ -1974,10 +1990,7 @@ server.listen(currentPort, (err) => {
dir: path.join(__dirname),
dev: false,
customServer: false,
- conf: ${JSON.stringify({
- ...serverConfig,
- distDir: `./${path.relative(dir, distDir)}`,
- })},
+ conf: nextConfig,
})
handler = nextServer.getRequestHandler()
diff --git a/packages/next/src/compiled/react-dom-experimental/LICENSE b/packages/next/src/compiled/react-dom-experimental/LICENSE
new file mode 100644
index 0000000000000..b93be90515ccd
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js
new file mode 100644
index 0000000000000..abf8cc7690c16
--- /dev/null
+++ b/packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js
@@ -0,0 +1,10202 @@
+/**
+ * @license React
+ * react-dom-server-legacy.browser.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+if (process.env.NODE_ENV !== "production") {
+ (function() {
+'use strict';
+
+var React = require("next/dist/compiled/react-experimental");
+var ReactDOM = require('react-dom');
+
+var ReactVersion = '18.3.0-experimental-c8369527e-20230420';
+
+var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+// by calls to these methods by a Babel plugin.
+//
+// In PROD (or in packages without access to React internals),
+// they are left as they are instead.
+
+function warn(format) {
+ {
+ {
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+ writeChunkAndReturn(destination, chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+ return destination.push(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+ destination.push(null);
+}
+function stringToChunk(content) {
+ return content;
+}
+function stringToPrecomputedChunk(content) {
+ return content;
+}
+function clonePrecomputedChunk(chunk) {
+ return chunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.destroy(error);
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // ");Ua=!0;b.length=0;c.length=0}}}
+function Xa(a,b,c){Ua=!1;Va=!0;b.forEach(Wa,a);Ua&&(c.stylesToHoist=!0);return Va}function K(a){if(0===(a.state&7)){for(var b=a.chunks,c=0;c');for(b=0;b");a.length=0;c.length=0}}
+function bb(a){if("style"!==a.type){var b=a.chunks,c=Ga(a.props.href,a.props);E(b,c);for(c=0;c")}else if(e)for(f=0;f"))}
+function fb(a,b,c){var d=0;b.preconnects.forEach(L,a);b.preconnects.clear();var e=c.preconnectChunks;for(d=0;d",instructions:0,externalRuntimeConfig:d,htmlChunks:null,headChunks:null,hasBody:!1,charsetChunks:[],preconnectChunks:[],preloadChunks:[],hoistableChunks:[],stylesToHoist:!1,generateStaticMarkup:a}}
+function kb(a,b,c,d){if(c.generateStaticMarkup)return a.push(v(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(v(b)),a=!0);return a}
+var lb=Symbol.for("react.element"),mb=Symbol.for("react.portal"),nb=Symbol.for("react.fragment"),ob=Symbol.for("react.strict_mode"),pb=Symbol.for("react.profiler"),qb=Symbol.for("react.provider"),rb=Symbol.for("react.context"),sb=Symbol.for("react.server_context"),tb=Symbol.for("react.forward_ref"),ub=Symbol.for("react.suspense"),vb=Symbol.for("react.suspense_list"),wb=Symbol.for("react.memo"),xb=Symbol.for("react.lazy"),yb=Symbol.for("react.scope"),zb=Symbol.for("react.debug_trace_mode"),Ab=Symbol.for("react.offscreen"),
+Bb=Symbol.for("react.legacy_hidden"),Cb=Symbol.for("react.cache"),Db=Symbol.for("react.default_value"),Eb=Symbol.for("react.memo_cache_sentinel"),Fb=Symbol.iterator;
+function Gb(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case nb:return"Fragment";case mb:return"Portal";case pb:return"Profiler";case ob:return"StrictMode";case ub:return"Suspense";case vb:return"SuspenseList";case Cb:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case rb:return(a.displayName||"Context")+".Consumer";case qb:return(a._context.displayName||"Context")+".Provider";case tb:var b=a.render;a=a.displayName;
+a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case wb:return b=a.displayName||null,null!==b?b:Gb(a.type)||"Memo";case xb:b=a._payload;a=a._init;try{return Gb(a(b))}catch(c){break}case sb:return(a.displayName||a._globalName)+".Provider"}return null}var Hb=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Ib={};function Jb(a,b){a=a.contextTypes;if(!a)return Ib;var c={},d;for(d in a)c[d]=b[d];return c}var M=null;
+function Kb(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(m(401));}else{if(null===c)throw Error(m(401));Kb(a,c)}b.context._currentValue2=b.value}}function Lb(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Lb(a)}function Mb(a){var b=a.parent;null!==b&&Mb(b);a.context._currentValue2=a.value}
+function Nb(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error(m(402));a.depth===b.depth?Kb(a,b):Nb(a,b)}function Ob(a,b){var c=b.parent;if(null===c)throw Error(m(402));a.depth===c.depth?Kb(a,c):Ob(a,c);b.context._currentValue2=b.value}function Pb(a){var b=M;b!==a&&(null===b?Mb(a):null===a?Lb(b):b.depth===a.depth?Kb(b,a):b.depth>a.depth?Nb(b,a):Ob(b,a),M=a)}
+var Qb={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Rb(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Qb;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:q({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Qb.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Vb(b)+e|c<>>=0;return 0===a?32:31-(Xb(a)/Yb|0)|0}var Zb=Error(m(460));function $b(){}
+function ac(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then($b,$b),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}bc=b;throw Zb;}}var bc=null;
+function cc(){if(null===bc)throw Error(m(459));var a=bc;bc=null;return a}function dc(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var ec="function"===typeof Object.is?Object.is:dc,N=null,fc=null,gc=null,O=null,P=!1,hc=!1,Q=0,R=0,S=null,U=null,ic=0;function V(){if(null===N)throw Error(m(321));return N}function jc(){if(0=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push("")}c.lastPushedText=!1}else{switch(d){case Bb:case zb:case ob:case pb:case nb:Z(a,b,null,e.children);return;case Ab:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case vb:Z(a,b,null,e.children);return;case yb:throw Error(m(343));case ub:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var h={id:null,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,forceClientRender:!1,
+completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},k=Dc(a,c.chunks.length,h,c.formatContext,!1,!1);c.children.push(k);c.lastPushedText=!1;var l=Dc(a,0,null,c.formatContext,!1,!1);l.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=l;a.resources.boundaryResources=h.resources;try{if(Kc(a,b,e),a.responseState.generateStaticMarkup||l.lastPushedText&&l.textEmbedded&&l.chunks.push("\x3c!-- --\x3e"),l.status=1,Lc(h,l),0===h.pendingTasks)break a}catch(n){l.status=
+4,h.forceClientRender=!0,h.errorDigest=Y(a,n)}finally{a.resources.boundaryResources=d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=Ec(a,null,f,d,k,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case tb:d=d.render;N={};fc=b;R=Q=0;S=c;c=d(e,f);e=lc(d,e,c,f);if(0!==Q){d=b.treeContext;b.treeContext=Ub(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case wb:d=d.type;e=Ic(d,e);Jc(a,b,c,
+d,e,f);return;case qb:c=e.children;d=d._context;e=e.value;f=d._currentValue2;d._currentValue2=e;g=M;M=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=M;if(null===a)throw Error(m(403));e=a.parentValue;a.context._currentValue2=e===Db?a.context._defaultValue:e;a=M=a.parent;b.context=a;return;case rb:e=e.children;e=e(d._currentValue2);Z(a,b,null,e);return;case xb:f=d._init;d=f(d._payload);e=Ic(d,e);Jc(a,b,c,d,e,void 0);return}throw Error(m(130,null==
+d?d:typeof d,""));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case lb:Jc(a,b,c,d.type,d.props,d.ref);return;case mb:throw Error(m(257));case xb:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(na(d)){Mc(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=Fb&&d[Fb]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=[];do e.push(d.value),d=c.next();while(!d.done);Mc(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,uc(d));
+if(d.$$typeof===rb||d.$$typeof===sb)return Z(a,b,null,d._currentValue2);a=Object.prototype.toString.call(d);throw Error(m(31,"[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a));}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=kb(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=kb(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}
+function Mc(a,b,c){for(var d=c.length,e=0;e');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g")),Rc(a,b,c),a=a.responseState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(0a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Na(b,a.responseState,d.id),Rc(a,b,c),b.push("\x3c!--/$--\x3e");(c=a.resources.boundaryResources)&&d.resources.forEach(ib,c);a.responseState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error(m(391));Sc(a,b,c[0]);
+a=a.responseState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e");return a}function Tc(a,b,c){Oa(b,a.responseState,c.formatContext,c.id);Sc(a,b,c);return Pa(b,c.formatContext)}
+function Uc(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e"):b.push('">');return b}
+function Vc(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error(m(392));return Tc(a,b,d)}Tc(a,b,d);a=a.responseState;(c=0===a.streamingFormat)?(b.push(a.startInlineScript),0===(a.instructions&1)?(a.instructions|=1,b.push('$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("')):b.push('$RS("')):b.push(''):b.push('">');return b}
+function Qc(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(0===a.pendingRootTasks){db(b,a.resources,a.responseState,0===a.allPendingTasks);Sc(a,b,d);a.completedRootSegment=null;var e=a.responseState.bootstrapChunks;for(d=0;d"):!e.push('">')){a.destination=null;c++;f.splice(0,c);return}}f.splice(0,c);var T=a.completedBoundaries;for(c=0;c")),a.htmlChunks&&(b.push("")),b.push(null))}}function Wc(a,b){try{var c=a.abortableTasks;if(0 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ callback();
+}
+function beginWriting(destination) {}
+function writeChunk(destination, chunk) {
+ writeChunkAndReturn(destination, chunk);
+}
+function writeChunkAndReturn(destination, chunk) {
+ return destination.push(chunk);
+}
+function completeWriting(destination) {}
+function close(destination) {
+ destination.push(null);
+}
+function stringToChunk(content) {
+ return content;
+}
+function stringToPrecomputedChunk(content) {
+ return content;
+}
+function clonePrecomputedChunk(chunk) {
+ return chunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.destroy(error);
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+function _inheritsLoose(subClass, superClass) {
+ subClass.prototype = Object.create(superClass.prototype);
+ subClass.prototype.constructor = subClass;
+ subClass.__proto__ = superClass;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // ");Va=!0;b.length=0;c.length=0}}}
+function Ya(a,b,c){Va=!1;Wa=!0;b.forEach(Xa,a);Va&&(c.stylesToHoist=!0);return Wa}function J(a){if(0===(a.state&7)){for(var b=a.chunks,c=0;c');for(b=0;b");a.length=0;c.length=0}}
+function cb(a){if("style"!==a.type){var b=a.chunks,c=Ha(a.props.href,a.props);D(b,c);for(c=0;c")}else if(e)for(f=0;f"))}
+function gb(a,b,c){var d=0;b.preconnects.forEach(K,a);b.preconnects.clear();var e=c.preconnectChunks;for(d=0;d",instructions:0,externalRuntimeConfig:d,htmlChunks:null,headChunks:null,hasBody:!1,charsetChunks:[],preconnectChunks:[],preloadChunks:[],hoistableChunks:[],stylesToHoist:!1,generateStaticMarkup:a}}
+function lb(){return{insertionMode:2,selectedValue:null,noscriptTagInScope:!1}}function mb(a,b,c,d){if(c.generateStaticMarkup)return a.push(u(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(u(b)),a=!0);return a}
+var nb=Symbol.for("react.element"),ob=Symbol.for("react.portal"),pb=Symbol.for("react.fragment"),qb=Symbol.for("react.strict_mode"),rb=Symbol.for("react.profiler"),sb=Symbol.for("react.provider"),tb=Symbol.for("react.context"),ub=Symbol.for("react.server_context"),vb=Symbol.for("react.forward_ref"),wb=Symbol.for("react.suspense"),xb=Symbol.for("react.suspense_list"),yb=Symbol.for("react.memo"),zb=Symbol.for("react.lazy"),Ab=Symbol.for("react.scope"),Bb=Symbol.for("react.debug_trace_mode"),Cb=Symbol.for("react.offscreen"),
+Db=Symbol.for("react.legacy_hidden"),Eb=Symbol.for("react.cache"),Fb=Symbol.for("react.default_value"),Gb=Symbol.for("react.memo_cache_sentinel"),Hb=Symbol.iterator;
+function Ib(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case pb:return"Fragment";case ob:return"Portal";case rb:return"Profiler";case qb:return"StrictMode";case wb:return"Suspense";case xb:return"SuspenseList";case Eb:return"Cache"}if("object"===typeof a)switch(a.$$typeof){case tb:return(a.displayName||"Context")+".Consumer";case sb:return(a._context.displayName||"Context")+".Provider";case vb:var b=a.render;a=a.displayName;
+a||(a=b.displayName||b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case yb:return b=a.displayName||null,null!==b?b:Ib(a.type)||"Memo";case zb:b=a._payload;a=a._init;try{return Ib(a(b))}catch(c){break}case ub:return(a.displayName||a._globalName)+".Provider"}return null}var Jb=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Kb={};function Lb(a,b){a=a.contextTypes;if(!a)return Kb;var c={},d;for(d in a)c[d]=b[d];return c}var L=null;
+function Mb(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");}else{if(null===c)throw Error("The stacks must reach the root at the same time. This is a bug in React.");Mb(a,c)}b.context._currentValue2=b.value}}function Nb(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Nb(a)}
+function Ob(a){var b=a.parent;null!==b&&Ob(b);a.context._currentValue2=a.value}function Pb(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===b.depth?Mb(a,b):Pb(a,b)}
+function Qb(a,b){var c=b.parent;if(null===c)throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");a.depth===c.depth?Mb(a,c):Qb(a,c);b.context._currentValue2=b.value}function Rb(a){var b=L;b!==a&&(null===b?Ob(a):null===a?Nb(b):b.depth===a.depth?Mb(b,a):b.depth>a.depth?Pb(b,a):Qb(b,a),L=a)}
+var Sb={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Tb(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Sb;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:p({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Sb.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Xb(b)+e|c<>>=0;return 0===a?32:31-(Zb(a)/$b|0)|0}var ac=Error("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`");
+function bc(){}function cc(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(bc,bc),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}dc=b;throw ac;}}var dc=null;
+function ec(){if(null===dc)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=dc;dc=null;return a}function fc(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var gc="function"===typeof Object.is?Object.is:fc,M=null,hc=null,ic=null,N=null,O=!1,jc=!1,P=0,Q=0,R=null,T=null,kc=0;
+function U(){if(null===M)throw 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:\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://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return M}
+function lc(){if(0=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push("")}c.lastPushedText=!1}else{switch(d){case Db:case Bb:case qb:case rb:case pb:Z(a,b,null,e.children);return;case Cb:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case xb:Z(a,b,null,e.children);return;case Ab:throw Error("ReactDOMServer does not yet support scope components.");case wb:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var h={id:null,rootSegmentID:-1,
+parentFlushed:!1,pendingTasks:0,forceClientRender:!1,completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},k=Fc(a,c.chunks.length,h,c.formatContext,!1,!1);c.children.push(k);c.lastPushedText=!1;var l=Fc(a,0,null,c.formatContext,!1,!1);l.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=l;a.resources.boundaryResources=h.resources;try{if(Lc(a,b,e),a.responseState.generateStaticMarkup||l.lastPushedText&&l.textEmbedded&&l.chunks.push("\x3c!-- --\x3e"),l.status=
+1,Mc(h,l),0===h.pendingTasks)break a}catch(m){l.status=4,h.forceClientRender=!0,h.errorDigest=X(a,m)}finally{a.resources.boundaryResources=d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=Gc(a,null,f,d,k,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case vb:d=d.render;M={};hc=b;Q=P=0;R=c;c=d(e,f);e=nc(d,e,c,f);if(0!==P){d=b.treeContext;b.treeContext=Wb(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,
+b,null,e);return;case yb:d=d.type;e=Jc(d,e);Kc(a,b,c,d,e,f);return;case sb:c=e.children;d=d._context;e=e.value;f=d._currentValue2;d._currentValue2=e;g=L;L=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=L;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");e=a.parentValue;a.context._currentValue2=e===Fb?a.context._defaultValue:e;a=L=a.parent;b.context=a;return;case tb:e=e.children;e=e(d._currentValue2);
+Z(a,b,null,e);return;case zb:f=d._init;d=f(d._payload);e=Jc(d,e);Kc(a,b,c,d,e,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==d?d:typeof d)+"."));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case nb:Kc(a,b,c,d.type,d.props,d.ref);return;case ob:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case zb:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(oa(d)){Nc(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=Hb&&d[Hb]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=
+[];do e.push(d.value),d=c.next();while(!d.done);Nc(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,wc(d));if(d.$$typeof===tb||d.$$typeof===ub)return Z(a,b,null,d._currentValue2);a=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=
+mb(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=mb(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}function Nc(a,b,c){for(var d=c.length,e=0;e');case 1:c.status=2;var e=!0;d=c.chunks;var f=0;c=c.children;for(var g=0;g")),Sc(a,b,c),a=a.responseState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e"),a;if(0a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Oa(b,a.responseState,d.id),Sc(a,b,c),b.push("\x3c!--/$--\x3e");(c=a.resources.boundaryResources)&&d.resources.forEach(jb,c);a.responseState.generateStaticMarkup||b.push("\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");
+Tc(a,b,c[0]);a=a.responseState.generateStaticMarkup?!0:b.push("\x3c!--/$--\x3e");return a}function Uc(a,b,c){Pa(b,a.responseState,c.formatContext,c.id);Tc(a,b,c);return Ra(b,c.formatContext)}
+function Vc(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e"):b.push('">');return b}
+function Wc(a,b,c,d){if(2===d.status)return!0;var e=d.id;if(-1===e){if(-1===(d.id=c.rootSegmentID))throw Error("A root segment ID must have been assigned by now. This is a bug in React.");return Uc(a,b,d)}Uc(a,b,d);a=a.responseState;(c=0===a.streamingFormat)?(b.push(a.startInlineScript),0===(a.instructions&1)?(a.instructions|=1,b.push('$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("')):
+b.push('$RS("')):b.push(''):b.push('">');return b}
+function Rc(a,b){try{var c,d=a.completedRootSegment;if(null!==d)if(0===a.pendingRootTasks){eb(b,a.resources,a.responseState,0===a.allPendingTasks);Tc(a,b,d);a.completedRootSegment=null;var e=a.responseState.bootstrapChunks;for(d=0;d"):!e.push('">')){a.destination=null;c++;f.splice(0,c);return}}f.splice(0,c);var S=a.completedBoundaries;for(c=0;c")),a.htmlChunks&&(b.push("")),b.push(null))}}function Xc(a,b){if(1===a.status)a.status=2,b.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=b;try{Rc(a,b)}catch(c){X(a,c),Y(a,c)}}}
+function Yc(a,b){try{var c=a.abortableTasks;if(0 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ callback();
+}
+var VIEW_SIZE = 512;
+var currentView = null;
+var writtenBytes = 0;
+function beginWriting(destination) {
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+ if (chunk.length === 0) {
+ return;
+ }
+
+ if (chunk.length > VIEW_SIZE) {
+ {
+ if (precomputedChunkSet.has(chunk)) {
+ error('A large precomputed chunk was passed to writeChunk without being copied.' + ' Large chunks get enqueued directly and are not copied. This is incompatible with precomputed chunks because you cannot enqueue the same precomputed chunk twice.' + ' Use "cloneChunk" to make a copy of this large precomputed chunk before writing it. This is a bug in React.');
+ }
+ } // this chunk may overflow a single view which implies it was not
+ // one that is cached by the streaming renderer. We will enqueu
+ // it directly and expect it is not re-used
+
+
+ if (writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ destination.enqueue(chunk);
+ return;
+ }
+
+ var bytesToWrite = chunk;
+ var allowableBytes = currentView.length - writtenBytes;
+
+ if (allowableBytes < bytesToWrite.length) {
+ // this chunk would overflow the current view. We enqueue a full view
+ // and start a new view with the remaining chunk
+ if (allowableBytes === 0) {
+ // the current view is already full, send it
+ destination.enqueue(currentView);
+ } else {
+ // fill up the current view and apply the remaining chunk bytes
+ // to a new view.
+ currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+ destination.enqueue(currentView);
+ bytesToWrite = bytesToWrite.subarray(allowableBytes);
+ }
+
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ currentView.set(bytesToWrite, writtenBytes);
+ writtenBytes += bytesToWrite.length;
+}
+function writeChunkAndReturn(destination, chunk) {
+ writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+ return true;
+}
+function completeWriting(destination) {
+ if (currentView && writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = null;
+ writtenBytes = 0;
+ }
+}
+function close(destination) {
+ destination.close();
+}
+var textEncoder = new TextEncoder();
+function stringToChunk(content) {
+ return textEncoder.encode(content);
+}
+var precomputedChunkSet = new Set() ;
+function stringToPrecomputedChunk(content) {
+ var precomputedChunk = textEncoder.encode(content);
+
+ {
+ precomputedChunkSet.add(precomputedChunk);
+ }
+
+ return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+ return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[method-unbinding]
+ if (typeof destination.error === 'function') {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.error(error);
+ } else {
+ // Earlier implementations doesn't support this method. In that environment you're
+ // supposed to throw from a promise returned but we don't return a promise in our
+ // approach. We could fork this implementation but this is environment is an edge
+ // case to begin with. It's even less common to run this in an older environment.
+ // Even then, this is not where errors are supposed to happen and they get reported
+ // to a global callback in addition to this anyway. So it's fine just to close this.
+ destination.close();
+ }
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // "),Ac=!1,Bc=!0;function Cc(a){if("stylesheet"===a.type&&0===(a.state&1))Ac=!0;else if("style"===a.type){var b=a.chunks,c=a.props.hrefs,d=0;if(b.length){q(this,wc);q(this,x(D(a.props.precedence)));if(c.length){for(q(this,xc);d'),Lc=z("");function Mc(a,b){Gc=!1;a.forEach(Hc,this);a.clear();a=Fc.chunks;var c=Fc.props.hrefs;if(!1===Gc||a.length){q(this,Ic);q(this,x(D(b)));b=0;if(c.length){for(q(this,Jc);ba.depth?Bd(b,a):Cd(b,a),xd=a)}
+var Ed={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Fd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Ed;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:A({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Ed.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Id(b)+e|c<>>=0;return 0===a?32:31-(Kd(a)/Ld|0)|0}var Md=Error(k(460));function Nd(){}
+function Od(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Nd,Nd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Pd=b;throw Md;}}var Pd=null;
+function Qd(){if(null===Pd)throw Error(k(459));var a=Pd;Pd=null;return a}function Rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Sd="function"===typeof Object.is?Object.is:Rd,W=null,Td=null,Ud=null,X=null,Vd=!1,Wd=!1,Xd=0,Yd=0,Zd=null,Y=null,$d=0;function ae(){if(null===W)throw Error(k(321));return W}function be(){if(0<$d)throw Error(k(312));return{memoizedState:null,queue:null,next:null}}
+function ce(){null===X?null===Ud?(Vd=!1,Ud=X=be()):(Vd=!0,X=Ud):null===X.next?(Vd=!1,X=X.next=be()):(Vd=!0,X=X.next);return X}function de(a,b,c,d){for(;Wd;)Wd=!1,Yd=Xd=0,$d+=1,X=null,c=a(b,d);ee();return c}function fe(){var a=Zd;Zd=null;return a}function ee(){Td=W=null;Wd=!1;Ud=null;$d=0;X=Y=null}function ge(a,b){return"function"===typeof b?b(a):b}
+function he(a,b,c){W=ae();X=ce();if(Vd){var d=X.queue;b=d.dispatch;if(null!==Y&&(c=Y.get(d),void 0!==c)){Y.delete(d);d=X.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);X.memoizedState=d;return[d,b]}return[X.memoizedState,b]}a=a===ge?"function"===typeof b?b():b:void 0!==c?c(b):b;X.memoizedState=a;a=X.queue={last:null,dispatch:null};a=a.dispatch=ie.bind(null,W,a);return[X.memoizedState,a]}
+function je(a,b){W=ae();X=ce();b=void 0===b?null:b;if(null!==X){var c=X.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push(S,x(d),T)}c.lastPushedText=!1}else{switch(d){case od:case md:case bd:case cd:case ad:Z(a,b,null,e.children);return;case nd:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case id:Z(a,b,null,e.children);return;case ld:throw Error(k(343));case hd:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var h={id:null,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,forceClientRender:!1,
+completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},m=xe(a,c.chunks.length,h,c.formatContext,!1,!1);c.children.push(m);c.lastPushedText=!1;var p=xe(a,0,null,c.formatContext,!1,!1);p.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=p;a.resources.boundaryResources=h.resources;try{if(Fe(a,b,e),p.lastPushedText&&p.textEmbedded&&p.chunks.push(H),p.status=1,Ge(h,p),0===h.pendingTasks)break a}catch(r){p.status=4,h.forceClientRender=!0,h.errorDigest=Ae(a,r)}finally{a.resources.boundaryResources=
+d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=ye(a,null,f,d,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case gd:d=d.render;W={};Td=b;Yd=Xd=0;Zd=c;c=d(e,f);e=de(d,e,c,f);if(0!==Xd){d=b.treeContext;b.treeContext=Hd(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case jd:d=d.type;e=De(d,e);Ee(a,b,c,d,e,f);return;case dd:c=e.children;d=d._context;e=e.value;f=d._currentValue;d._currentValue=
+e;g=xd;xd=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=xd;if(null===a)throw Error(k(403));e=a.parentValue;a.context._currentValue=e===qd?a.context._defaultValue:e;a=xd=a.parent;b.context=a;return;case ed:e=e.children;e=e(d._currentValue);Z(a,b,null,e);return;case kd:f=d._init;d=f(d._payload);e=De(d,e);Ee(a,b,c,d,e,void 0);return}throw Error(k(130,null==d?d:typeof d,""));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Zc:Ee(a,b,c,d.type,d.props,d.ref);return;case $c:throw Error(k(257));case kd:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(ra(d)){He(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=sd&&d[sd]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=[];do e.push(d.value),d=c.next();while(!d.done);He(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,me(d));
+if(d.$$typeof===ed||d.$$typeof===fd)return Z(a,b,null,d._currentValue);a=Object.prototype.toString.call(d);throw Error(k(31,"[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a));}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}
+function He(a,b,c){for(var d=c.length,e=0;ea.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,
+a.completedBoundaries.push(d),tb(b,a.responseState,d.id),Me(a,b,c);else{(c=a.resources.boundaryResources)&&d.resources.forEach(Yc,c);u(b,kb);c=d.completedSegments;if(1!==c.length)throw Error(k(391));Ne(a,b,c[0])}return u(b,ob)}function Oe(a,b,c){Pb(b,a.responseState,c.formatContext,c.id);Ne(a,b,c);return Qb(b,c.formatContext)}
+function Pe(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ setTimeout(callback, 0);
+}
+
+var supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+supportsRequestStorage ? new AsyncLocalStorage() : null;
+var VIEW_SIZE = 512;
+var currentView = null;
+var writtenBytes = 0;
+function beginWriting(destination) {
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+ if (chunk.length === 0) {
+ return;
+ }
+
+ if (chunk.length > VIEW_SIZE) {
+ {
+ if (precomputedChunkSet.has(chunk)) {
+ error('A large precomputed chunk was passed to writeChunk without being copied.' + ' Large chunks get enqueued directly and are not copied. This is incompatible with precomputed chunks because you cannot enqueue the same precomputed chunk twice.' + ' Use "cloneChunk" to make a copy of this large precomputed chunk before writing it. This is a bug in React.');
+ }
+ } // this chunk may overflow a single view which implies it was not
+ // one that is cached by the streaming renderer. We will enqueu
+ // it directly and expect it is not re-used
+
+
+ if (writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ destination.enqueue(chunk);
+ return;
+ }
+
+ var bytesToWrite = chunk;
+ var allowableBytes = currentView.length - writtenBytes;
+
+ if (allowableBytes < bytesToWrite.length) {
+ // this chunk would overflow the current view. We enqueue a full view
+ // and start a new view with the remaining chunk
+ if (allowableBytes === 0) {
+ // the current view is already full, send it
+ destination.enqueue(currentView);
+ } else {
+ // fill up the current view and apply the remaining chunk bytes
+ // to a new view.
+ currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+ destination.enqueue(currentView);
+ bytesToWrite = bytesToWrite.subarray(allowableBytes);
+ }
+
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ currentView.set(bytesToWrite, writtenBytes);
+ writtenBytes += bytesToWrite.length;
+}
+function writeChunkAndReturn(destination, chunk) {
+ writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+ return true;
+}
+function completeWriting(destination) {
+ if (currentView && writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = null;
+ writtenBytes = 0;
+ }
+}
+function close(destination) {
+ destination.close();
+}
+var textEncoder = new TextEncoder();
+function stringToChunk(content) {
+ return textEncoder.encode(content);
+}
+var precomputedChunkSet = new Set() ;
+function stringToPrecomputedChunk(content) {
+ var precomputedChunk = textEncoder.encode(content);
+
+ {
+ precomputedChunkSet.add(precomputedChunk);
+ }
+
+ return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+ return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[method-unbinding]
+ if (typeof destination.error === 'function') {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.error(error);
+ } else {
+ // Earlier implementations doesn't support this method. In that environment you're
+ // supposed to throw from a promise returned but we don't return a promise in our
+ // approach. We could fork this implementation but this is environment is an edge
+ // case to begin with. It's even less common to run this in an older environment.
+ // Even then, this is not where errors are supposed to happen and they get reported
+ // to a global callback in addition to this anyway. So it's fine just to close this.
+ destination.close();
+ }
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // "),Ac=!1,Bc=!0;function Cc(a){if("stylesheet"===a.type&&0===(a.state&1))Ac=!0;else if("style"===a.type){var b=a.chunks,c=a.props.hrefs,d=0;if(b.length){n(this,wc);n(this,w(C(a.props.precedence)));if(c.length){for(n(this,xc);d'),Lc=y("");function Mc(a,b){Gc=!1;a.forEach(Hc,this);a.clear();a=Fc.chunks;var c=Fc.props.hrefs;if(!1===Gc||a.length){n(this,Ic);n(this,w(C(b)));b=0;if(c.length){for(n(this,Jc);ba.depth?Ad(b,a):Bd(b,a),V=a)}
+var Dd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Ed(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Dd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:z({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Dd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Hd(b)+e|c<>>=0;return 0===a?32:31-(Jd(a)/Kd|0)|0}var Ld=Error("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`");
+function Md(){}function Nd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Md,Md),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Od=b;throw Ld;}}var Od=null;
+function Pd(){if(null===Od)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Od;Od=null;return a}function Qd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Rd="function"===typeof Object.is?Object.is:Qd,W=null,Sd=null,Td=null,X=null,Ud=!1,Vd=!1,Wd=0,Xd=0,Yd=null,Y=null,Zd=0;
+function $d(){if(null===W)throw 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:\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://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return W}
+function ae(){if(0=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push(R,w(d),S)}c.lastPushedText=!1}else{switch(d){case od:case md:case bd:case cd:case ad:Z(a,b,null,e.children);return;case nd:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case id:Z(a,b,null,e.children);return;case ld:throw Error("ReactDOMServer does not yet support scope components.");case hd:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var h={id:null,rootSegmentID:-1,
+parentFlushed:!1,pendingTasks:0,forceClientRender:!1,completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},m=we(a,c.chunks.length,h,c.formatContext,!1,!1);c.children.push(m);c.lastPushedText=!1;var p=we(a,0,null,c.formatContext,!1,!1);p.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=p;a.resources.boundaryResources=h.resources;try{if(Fe(a,b,e),p.lastPushedText&&p.textEmbedded&&p.chunks.push(G),p.status=1,Ge(h,p),0===h.pendingTasks)break a}catch(r){p.status=
+4,h.forceClientRender=!0,h.errorDigest=Ae(a,r)}finally{a.resources.boundaryResources=d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=xe(a,null,f,d,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case gd:d=d.render;W={};Sd=b;Xd=Wd=0;Yd=c;c=d(e,f);e=ce(d,e,c,f);if(0!==Wd){d=b.treeContext;b.treeContext=Gd(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case jd:d=d.type;e=De(d,e);Ee(a,
+b,c,d,e,f);return;case dd:c=e.children;d=d._context;e=e.value;f=d._currentValue;d._currentValue=e;g=V;V=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=V;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");e=a.parentValue;a.context._currentValue=e===qd?a.context._defaultValue:e;a=V=a.parent;b.context=a;return;case ed:e=e.children;e=e(d._currentValue);Z(a,b,null,e);return;case kd:f=d._init;d=f(d._payload);
+e=De(d,e);Ee(a,b,c,d,e,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==d?d:typeof d)+"."));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Zc:Ee(a,b,c,d.type,d.props,d.ref);return;case $c:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case kd:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(ra(d)){He(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=sd&&d[sd]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=
+[];do e.push(d.value),d=c.next();while(!d.done);He(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,le(d));if(d.$$typeof===ed||d.$$typeof===fd)return Z(a,b,null,d._currentValue);a=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=
+La(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}function He(a,b,c){for(var d=c.length,e=0;ea.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),
+tb(b,a.responseState,d.id),Me(a,b,c);else{(c=a.resources.boundaryResources)&&d.resources.forEach(Yc,c);t(b,kb);c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");Ne(a,b,c[0])}return t(b,ob)}function Oe(a,b,c){Pb(b,a.responseState,c.formatContext,c.id);Ne(a,b,c);return Qb(b,c.formatContext)}
+function Pe(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ setImmediate(callback);
+}
+function flushBuffered(destination) {
+ // If we don't have any more data to send right now.
+ // Flush whatever is in the buffer to the wire.
+ if (typeof destination.flush === 'function') {
+ // By convention the Zlib streams provide a flush function for this purpose.
+ // For Express, compression middleware adds this method.
+ destination.flush();
+ }
+}
+new async_hooks.AsyncLocalStorage();
+var VIEW_SIZE = 2048;
+var currentView = null;
+var writtenBytes = 0;
+var destinationHasCapacity$1 = true;
+function beginWriting(destination) {
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ destinationHasCapacity$1 = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+ if (stringChunk.length === 0) {
+ return;
+ } // maximum possible view needed to encode entire string
+
+
+ if (stringChunk.length * 3 > VIEW_SIZE) {
+ if (writtenBytes > 0) {
+ writeToDestination(destination, currentView.subarray(0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ writeToDestination(destination, textEncoder.encode(stringChunk));
+ return;
+ }
+
+ var target = currentView;
+
+ if (writtenBytes > 0) {
+ target = currentView.subarray(writtenBytes);
+ }
+
+ var _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+ read = _textEncoder$encodeIn.read,
+ written = _textEncoder$encodeIn.written;
+
+ writtenBytes += written;
+
+ if (read < stringChunk.length) {
+ writeToDestination(destination, currentView.subarray(0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+ }
+
+ if (writtenBytes === VIEW_SIZE) {
+ writeToDestination(destination, currentView);
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+}
+
+function writeViewChunk(destination, chunk) {
+ if (chunk.byteLength === 0) {
+ return;
+ }
+
+ if (chunk.byteLength > VIEW_SIZE) {
+ {
+ if (precomputedChunkSet && precomputedChunkSet.has(chunk)) {
+ error('A large precomputed chunk was passed to writeChunk without being copied.' + ' Large chunks get enqueued directly and are not copied. This is incompatible with precomputed chunks because you cannot enqueue the same precomputed chunk twice.' + ' Use "cloneChunk" to make a copy of this large precomputed chunk before writing it. This is a bug in React.');
+ }
+ } // this chunk may overflow a single view which implies it was not
+ // one that is cached by the streaming renderer. We will enqueu
+ // it directly and expect it is not re-used
+
+
+ if (writtenBytes > 0) {
+ writeToDestination(destination, currentView.subarray(0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ writeToDestination(destination, chunk);
+ return;
+ }
+
+ var bytesToWrite = chunk;
+ var allowableBytes = currentView.length - writtenBytes;
+
+ if (allowableBytes < bytesToWrite.byteLength) {
+ // this chunk would overflow the current view. We enqueue a full view
+ // and start a new view with the remaining chunk
+ if (allowableBytes === 0) {
+ // the current view is already full, send it
+ writeToDestination(destination, currentView);
+ } else {
+ // fill up the current view and apply the remaining chunk bytes
+ // to a new view.
+ currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+ writtenBytes += allowableBytes;
+ writeToDestination(destination, currentView);
+ bytesToWrite = bytesToWrite.subarray(allowableBytes);
+ }
+
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ currentView.set(bytesToWrite, writtenBytes);
+ writtenBytes += bytesToWrite.byteLength;
+
+ if (writtenBytes === VIEW_SIZE) {
+ writeToDestination(destination, currentView);
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+}
+
+function writeChunk(destination, chunk) {
+ if (typeof chunk === 'string') {
+ writeStringChunk(destination, chunk);
+ } else {
+ writeViewChunk(destination, chunk);
+ }
+}
+
+function writeToDestination(destination, view) {
+ var currentHasCapacity = destination.write(view);
+ destinationHasCapacity$1 = destinationHasCapacity$1 && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+ writeChunk(destination, chunk);
+ return destinationHasCapacity$1;
+}
+function completeWriting(destination) {
+ if (currentView && writtenBytes > 0) {
+ destination.write(currentView.subarray(0, writtenBytes));
+ }
+
+ currentView = null;
+ writtenBytes = 0;
+ destinationHasCapacity$1 = true;
+}
+function close(destination) {
+ destination.end();
+}
+var textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+ return content;
+}
+var precomputedChunkSet = new Set() ;
+function stringToPrecomputedChunk(content) {
+ var precomputedChunk = textEncoder.encode(content);
+
+ {
+ if (precomputedChunkSet) {
+ precomputedChunkSet.add(precomputedChunk);
+ }
+ }
+
+ return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+ return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.destroy(error);
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // "),Bc=!1,Cc=!0;function Dc(a){if("stylesheet"===a.type&&0===(a.state&1))Bc=!0;else if("style"===a.type){var b=a.chunks,c=a.props.hrefs,d=0;if(b.length){p(this,xc);p(this,B(a.props.precedence));if(c.length){for(p(this,yc);d'),Mc=y("");function Nc(a,b){Hc=!1;a.forEach(Ic,this);a.clear();a=Gc.chunks;var c=Gc.props.hrefs;if(!1===Hc||a.length){p(this,Jc);p(this,B(b));b=0;if(c.length){for(p(this,Kc);ba.depth?Bd(b,a):Cd(b,a),V=a)}
+var Ed={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Fd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Ed;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:z({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Ed.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Id(b)+e|c<>>=0;return 0===a?32:31-(Kd(a)/Ld|0)|0}var Md=Error("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`");
+function Nd(){}function Od(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Nd,Nd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Pd=b;throw Md;}}var Pd=null;
+function Qd(){if(null===Pd)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Pd;Pd=null;return a}function Rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Sd="function"===typeof Object.is?Object.is:Rd,W=null,Td=null,Ud=null,X=null,Vd=!1,Wd=!1,Xd=0,Yd=0,Zd=null,Y=null,$d=0;
+function ae(){if(null===W)throw 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:\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://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return W}
+function be(){if(0<$d)throw Error("Rendered more hooks than during the previous render");return{memoizedState:null,queue:null,next:null}}function ce(){null===X?null===Ud?(Vd=!1,Ud=X=be()):(Vd=!0,X=Ud):null===X.next?(Vd=!1,X=X.next=be()):(Vd=!0,X=X.next);return X}function de(a,b,c,d){for(;Wd;)Wd=!1,Yd=Xd=0,$d+=1,X=null,c=a(b,d);ee();return c}function fe(){var a=Zd;Zd=null;return a}function ee(){Td=W=null;Wd=!1;Ud=null;$d=0;X=Y=null}function ge(a,b){return"function"===typeof b?b(a):b}
+function he(a,b,c){W=ae();X=ce();if(Vd){var d=X.queue;b=d.dispatch;if(null!==Y&&(c=Y.get(d),void 0!==c)){Y.delete(d);d=X.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);X.memoizedState=d;return[d,b]}return[X.memoizedState,b]}a=a===ge?"function"===typeof b?b():b:void 0!==c?c(b):b;X.memoizedState=a;a=X.queue={last:null,dispatch:null};a=a.dispatch=ie.bind(null,W,a);return[X.memoizedState,a]}
+function je(a,b){W=ae();X=ce();b=void 0===b?null:b;if(null!==X){var c=X.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push(R,d,S)}c.lastPushedText=!1}else{switch(d){case pd:case nd:case cd:case dd:case bd:Z(a,b,null,e.children);return;case od:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case jd:Z(a,b,null,e.children);return;case md:throw Error("ReactDOMServer does not yet support scope components.");case id:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var h={id:null,rootSegmentID:-1,
+parentFlushed:!1,pendingTasks:0,forceClientRender:!1,completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},m=ze(a,c.chunks.length,h,c.formatContext,!1,!1);c.children.push(m);c.lastPushedText=!1;var n=ze(a,0,null,c.formatContext,!1,!1);n.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=n;a.resources.boundaryResources=h.resources;try{if(Fe(a,b,e),n.lastPushedText&&n.textEmbedded&&n.chunks.push(G),n.status=1,Ge(h,n),0===h.pendingTasks)break a}catch(q){n.status=
+4,h.forceClientRender=!0,h.errorDigest=Ae(a,q)}finally{a.resources.boundaryResources=d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=ye(a,null,f,d,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case hd:d=d.render;W={};Td=b;Yd=Xd=0;Zd=c;c=d(e,f);e=de(d,e,c,f);if(0!==Xd){d=b.treeContext;b.treeContext=Hd(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case kd:d=d.type;e=De(d,e);Ee(a,
+b,c,d,e,f);return;case ed:c=e.children;d=d._context;e=e.value;f=d._currentValue;d._currentValue=e;g=V;V=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=V;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");e=a.parentValue;a.context._currentValue=e===rd?a.context._defaultValue:e;a=V=a.parent;b.context=a;return;case fd:e=e.children;e=e(d._currentValue);Z(a,b,null,e);return;case ld:f=d._init;d=f(d._payload);
+e=De(d,e);Ee(a,b,c,d,e,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==d?d:typeof d)+"."));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case $c:Ee(a,b,c,d.type,d.props,d.ref);return;case ad:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case ld:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(ua(d)){He(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=td&&d[td]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=
+[];do e.push(d.value),d=c.next();while(!d.done);He(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,me(d));if(d.$$typeof===fd||d.$$typeof===gd)return Z(a,b,null,d._currentValue);a=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=
+Ma(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=Ma(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}function He(a,b,c){for(var d=c.length,e=0;ea.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),
+ub(b,a.responseState,d.id),Me(a,b,c);else{(c=a.resources.boundaryResources)&&d.resources.forEach(Zc,c);x(b,lb);c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");Ne(a,b,c[0])}return x(b,pb)}function Oe(a,b,c){Qb(b,a.responseState,c.formatContext,c.id);Ne(a,b,c);return Rb(b,c.formatContext)}
+function Pe(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e');var m=[],n=null,q=0;void 0!==e&&m.push(d,(""+e).replace(Ja,Ka),Ea);void 0!==h&&(q=1,n="string"===typeof h?{src:h,integrity:void 0}:h);if(void 0!==f)for(e=0;e 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ callback();
+}
+var VIEW_SIZE = 512;
+var currentView = null;
+var writtenBytes = 0;
+function beginWriting(destination) {
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+ if (chunk.length === 0) {
+ return;
+ }
+
+ if (chunk.length > VIEW_SIZE) {
+ {
+ if (precomputedChunkSet.has(chunk)) {
+ error('A large precomputed chunk was passed to writeChunk without being copied.' + ' Large chunks get enqueued directly and are not copied. This is incompatible with precomputed chunks because you cannot enqueue the same precomputed chunk twice.' + ' Use "cloneChunk" to make a copy of this large precomputed chunk before writing it. This is a bug in React.');
+ }
+ } // this chunk may overflow a single view which implies it was not
+ // one that is cached by the streaming renderer. We will enqueu
+ // it directly and expect it is not re-used
+
+
+ if (writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ destination.enqueue(chunk);
+ return;
+ }
+
+ var bytesToWrite = chunk;
+ var allowableBytes = currentView.length - writtenBytes;
+
+ if (allowableBytes < bytesToWrite.length) {
+ // this chunk would overflow the current view. We enqueue a full view
+ // and start a new view with the remaining chunk
+ if (allowableBytes === 0) {
+ // the current view is already full, send it
+ destination.enqueue(currentView);
+ } else {
+ // fill up the current view and apply the remaining chunk bytes
+ // to a new view.
+ currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+ destination.enqueue(currentView);
+ bytesToWrite = bytesToWrite.subarray(allowableBytes);
+ }
+
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ currentView.set(bytesToWrite, writtenBytes);
+ writtenBytes += bytesToWrite.length;
+}
+function writeChunkAndReturn(destination, chunk) {
+ writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+ return true;
+}
+function completeWriting(destination) {
+ if (currentView && writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = null;
+ writtenBytes = 0;
+ }
+}
+function close(destination) {
+ destination.close();
+}
+var textEncoder = new TextEncoder();
+function stringToChunk(content) {
+ return textEncoder.encode(content);
+}
+var precomputedChunkSet = new Set() ;
+function stringToPrecomputedChunk(content) {
+ var precomputedChunk = textEncoder.encode(content);
+
+ {
+ precomputedChunkSet.add(precomputedChunk);
+ }
+
+ return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+ return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[method-unbinding]
+ if (typeof destination.error === 'function') {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.error(error);
+ } else {
+ // Earlier implementations doesn't support this method. In that environment you're
+ // supposed to throw from a promise returned but we don't return a promise in our
+ // approach. We could fork this implementation but this is environment is an edge
+ // case to begin with. It's even less common to run this in an older environment.
+ // Even then, this is not where errors are supposed to happen and they get reported
+ // to a global callback in addition to this anyway. So it's fine just to close this.
+ destination.close();
+ }
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // "),Ac=!1,Bc=!0;function Cc(a){if("stylesheet"===a.type&&0===(a.state&1))Ac=!0;else if("style"===a.type){var b=a.chunks,c=a.props.hrefs,d=0;if(b.length){q(this,wc);q(this,w(D(a.props.precedence)));if(c.length){for(q(this,xc);d'),Lc=z("");function Mc(a,b){Gc=!1;a.forEach(Hc,this);a.clear();a=Fc.chunks;var c=Fc.props.hrefs;if(!1===Gc||a.length){q(this,Ic);q(this,w(D(b)));b=0;if(c.length){for(q(this,Jc);ba.depth?Bd(b,a):Cd(b,a),xd=a)}
+var Ed={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Fd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Ed;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:A({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Ed.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Id(b)+e|c<>>=0;return 0===a?32:31-(Kd(a)/Ld|0)|0}var Md=Error(h(460));function Nd(){}
+function Od(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Nd,Nd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Pd=b;throw Md;}}var Pd=null;
+function Qd(){if(null===Pd)throw Error(h(459));var a=Pd;Pd=null;return a}function Rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Sd="function"===typeof Object.is?Object.is:Rd,W=null,Td=null,Ud=null,X=null,Vd=!1,Wd=!1,Xd=0,Yd=0,Zd=null,Y=null,$d=0;function ae(){if(null===W)throw Error(h(321));return W}function be(){if(0<$d)throw Error(h(312));return{memoizedState:null,queue:null,next:null}}
+function ce(){null===X?null===Ud?(Vd=!1,Ud=X=be()):(Vd=!0,X=Ud):null===X.next?(Vd=!1,X=X.next=be()):(Vd=!0,X=X.next);return X}function de(a,b,c,d){for(;Wd;)Wd=!1,Yd=Xd=0,$d+=1,X=null,c=a(b,d);ee();return c}function fe(){var a=Zd;Zd=null;return a}function ee(){Td=W=null;Wd=!1;Ud=null;$d=0;X=Y=null}function ge(a,b){return"function"===typeof b?b(a):b}
+function he(a,b,c){W=ae();X=ce();if(Vd){var d=X.queue;b=d.dispatch;if(null!==Y&&(c=Y.get(d),void 0!==c)){Y.delete(d);d=X.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);X.memoizedState=d;return[d,b]}return[X.memoizedState,b]}a=a===ge?"function"===typeof b?b():b:void 0!==c?c(b):b;X.memoizedState=a;a=X.queue={last:null,dispatch:null};a=a.dispatch=ie.bind(null,W,a);return[X.memoizedState,a]}
+function je(a,b){W=ae();X=ce();b=void 0===b?null:b;if(null!==X){var c=X.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push(S,w(d),T)}c.lastPushedText=!1}else{switch(d){case od:case md:case bd:case cd:case ad:Z(a,b,null,e.children);return;case nd:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case id:Z(a,b,null,e.children);return;case ld:throw Error(h(343));case hd:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var k={id:null,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,forceClientRender:!1,
+completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},m=xe(a,c.chunks.length,k,c.formatContext,!1,!1);c.children.push(m);c.lastPushedText=!1;var p=xe(a,0,null,c.formatContext,!1,!1);p.parentFlushed=!0;b.blockedBoundary=k;b.blockedSegment=p;a.resources.boundaryResources=k.resources;try{if(Fe(a,b,e),p.lastPushedText&&p.textEmbedded&&p.chunks.push(H),p.status=1,Ge(k,p),0===k.pendingTasks)break a}catch(t){p.status=4,k.forceClientRender=!0,k.errorDigest=Ae(a,t)}finally{a.resources.boundaryResources=
+d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=ye(a,null,f,d,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case gd:d=d.render;W={};Td=b;Yd=Xd=0;Zd=c;c=d(e,f);e=de(d,e,c,f);if(0!==Xd){d=b.treeContext;b.treeContext=Hd(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case jd:d=d.type;e=De(d,e);Ee(a,b,c,d,e,f);return;case dd:c=e.children;d=d._context;e=e.value;f=d._currentValue;d._currentValue=
+e;g=xd;xd=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=xd;if(null===a)throw Error(h(403));e=a.parentValue;a.context._currentValue=e===qd?a.context._defaultValue:e;a=xd=a.parent;b.context=a;return;case ed:e=e.children;e=e(d._currentValue);Z(a,b,null,e);return;case kd:f=d._init;d=f(d._payload);e=De(d,e);Ee(a,b,c,d,e,void 0);return}throw Error(h(130,null==d?d:typeof d,""));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Zc:Ee(a,b,c,d.type,d.props,d.ref);return;case $c:throw Error(h(257));case kd:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(ra(d)){He(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=sd&&d[sd]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=[];do e.push(d.value),d=c.next();while(!d.done);He(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,me(d));
+if(d.$$typeof===ed||d.$$typeof===fd)return Z(a,b,null,d._currentValue);a=Object.prototype.toString.call(d);throw Error(h(31,"[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a));}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}
+function He(a,b,c){for(var d=c.length,e=0;ea.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,
+a.completedBoundaries.push(d),tb(b,a.responseState,d.id),Me(a,b,c);else{(c=a.resources.boundaryResources)&&d.resources.forEach(Yc,c);r(b,kb);c=d.completedSegments;if(1!==c.length)throw Error(h(391));Ne(a,b,c[0])}return r(b,ob)}function Oe(a,b,c){Pb(b,a.responseState,c.formatContext,c.id);Ne(a,b,c);return Qb(b,c.formatContext)}
+function Pe(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ setTimeout(callback, 0);
+}
+
+var supportsRequestStorage = typeof AsyncLocalStorage === 'function';
+supportsRequestStorage ? new AsyncLocalStorage() : null;
+var VIEW_SIZE = 512;
+var currentView = null;
+var writtenBytes = 0;
+function beginWriting(destination) {
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+}
+function writeChunk(destination, chunk) {
+ if (chunk.length === 0) {
+ return;
+ }
+
+ if (chunk.length > VIEW_SIZE) {
+ {
+ if (precomputedChunkSet.has(chunk)) {
+ error('A large precomputed chunk was passed to writeChunk without being copied.' + ' Large chunks get enqueued directly and are not copied. This is incompatible with precomputed chunks because you cannot enqueue the same precomputed chunk twice.' + ' Use "cloneChunk" to make a copy of this large precomputed chunk before writing it. This is a bug in React.');
+ }
+ } // this chunk may overflow a single view which implies it was not
+ // one that is cached by the streaming renderer. We will enqueu
+ // it directly and expect it is not re-used
+
+
+ if (writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ destination.enqueue(chunk);
+ return;
+ }
+
+ var bytesToWrite = chunk;
+ var allowableBytes = currentView.length - writtenBytes;
+
+ if (allowableBytes < bytesToWrite.length) {
+ // this chunk would overflow the current view. We enqueue a full view
+ // and start a new view with the remaining chunk
+ if (allowableBytes === 0) {
+ // the current view is already full, send it
+ destination.enqueue(currentView);
+ } else {
+ // fill up the current view and apply the remaining chunk bytes
+ // to a new view.
+ currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes); // writtenBytes += allowableBytes; // this can be skipped because we are going to immediately reset the view
+
+ destination.enqueue(currentView);
+ bytesToWrite = bytesToWrite.subarray(allowableBytes);
+ }
+
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ currentView.set(bytesToWrite, writtenBytes);
+ writtenBytes += bytesToWrite.length;
+}
+function writeChunkAndReturn(destination, chunk) {
+ writeChunk(destination, chunk); // in web streams there is no backpressure so we can alwas write more
+
+ return true;
+}
+function completeWriting(destination) {
+ if (currentView && writtenBytes > 0) {
+ destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
+ currentView = null;
+ writtenBytes = 0;
+ }
+}
+function close(destination) {
+ destination.close();
+}
+var textEncoder = new TextEncoder();
+function stringToChunk(content) {
+ return textEncoder.encode(content);
+}
+var precomputedChunkSet = new Set() ;
+function stringToPrecomputedChunk(content) {
+ var precomputedChunk = textEncoder.encode(content);
+
+ {
+ precomputedChunkSet.add(precomputedChunk);
+ }
+
+ return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+ return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[method-unbinding]
+ if (typeof destination.error === 'function') {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.error(error);
+ } else {
+ // Earlier implementations doesn't support this method. In that environment you're
+ // supposed to throw from a promise returned but we don't return a promise in our
+ // approach. We could fork this implementation but this is environment is an edge
+ // case to begin with. It's even less common to run this in an older environment.
+ // Even then, this is not where errors are supposed to happen and they get reported
+ // to a global callback in addition to this anyway. So it's fine just to close this.
+ destination.close();
+ }
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // "),Ac=!1,Bc=!0;function Cc(a){if("stylesheet"===a.type&&0===(a.state&1))Ac=!0;else if("style"===a.type){var b=a.chunks,c=a.props.hrefs,d=0;if(b.length){q(this,wc);q(this,w(D(a.props.precedence)));if(c.length){for(q(this,xc);d'),Lc=z("");function Mc(a,b){Gc=!1;a.forEach(Hc,this);a.clear();a=Fc.chunks;var c=Fc.props.hrefs;if(!1===Gc||a.length){q(this,Ic);q(this,w(D(b)));b=0;if(c.length){for(q(this,Jc);ba.depth?Bd(b,a):Cd(b,a),xd=a)}
+var Ed={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Fd(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Ed;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:A({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Ed.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Id(b)+e|c<>>=0;return 0===a?32:31-(Kd(a)/Ld|0)|0}var Md=Error(h(460));function Nd(){}
+function Od(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Nd,Nd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Pd=b;throw Md;}}var Pd=null;
+function Qd(){if(null===Pd)throw Error(h(459));var a=Pd;Pd=null;return a}function Rd(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Sd="function"===typeof Object.is?Object.is:Rd,W=null,Td=null,Ud=null,X=null,Vd=!1,Wd=!1,Xd=0,Yd=0,Zd=null,Y=null,$d=0;function ae(){if(null===W)throw Error(h(321));return W}function be(){if(0<$d)throw Error(h(312));return{memoizedState:null,queue:null,next:null}}
+function ce(){null===X?null===Ud?(Vd=!1,Ud=X=be()):(Vd=!0,X=Ud):null===X.next?(Vd=!1,X=X.next=be()):(Vd=!0,X=X.next);return X}function de(a,b,c,d){for(;Wd;)Wd=!1,Yd=Xd=0,$d+=1,X=null,c=a(b,d);ee();return c}function fe(){var a=Zd;Zd=null;return a}function ee(){Td=W=null;Wd=!1;Ud=null;$d=0;X=Y=null}function ge(a,b){return"function"===typeof b?b(a):b}
+function he(a,b,c){W=ae();X=ce();if(Vd){var d=X.queue;b=d.dispatch;if(null!==Y&&(c=Y.get(d),void 0!==c)){Y.delete(d);d=X.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);X.memoizedState=d;return[d,b]}return[X.memoizedState,b]}a=a===ge?"function"===typeof b?b():b:void 0!==c?c(b):b;X.memoizedState=a;a=X.queue={last:null,dispatch:null};a=a.dispatch=ie.bind(null,W,a);return[X.memoizedState,a]}
+function je(a,b){W=ae();X=ce();b=void 0===b?null:b;if(null!==X){var c=X.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var e=0;e=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push(S,w(d),T)}c.lastPushedText=!1}else{switch(d){case od:case md:case bd:case cd:case ad:Z(a,b,null,e.children);return;case nd:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case id:Z(a,b,null,e.children);return;case ld:throw Error(h(343));case hd:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var k={id:null,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,forceClientRender:!1,
+completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},m=xe(a,c.chunks.length,k,c.formatContext,!1,!1);c.children.push(m);c.lastPushedText=!1;var p=xe(a,0,null,c.formatContext,!1,!1);p.parentFlushed=!0;b.blockedBoundary=k;b.blockedSegment=p;a.resources.boundaryResources=k.resources;try{if(Ge(a,b,e),p.lastPushedText&&p.textEmbedded&&p.chunks.push(H),p.status=1,He(k,p),0===k.pendingTasks)break a}catch(u){p.status=4,k.forceClientRender=!0,k.errorDigest=Be(a,u)}finally{a.resources.boundaryResources=
+d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=ye(a,null,f,d,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case gd:d=d.render;W={};Td=b;Yd=Xd=0;Zd=c;c=d(e,f);e=de(d,e,c,f);if(0!==Xd){d=b.treeContext;b.treeContext=Hd(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case jd:d=d.type;e=Ee(d,e);Fe(a,b,c,d,e,f);return;case dd:c=e.children;d=d._context;e=e.value;f=d._currentValue;d._currentValue=
+e;g=xd;xd=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=xd;if(null===a)throw Error(h(403));e=a.parentValue;a.context._currentValue=e===qd?a.context._defaultValue:e;a=xd=a.parent;b.context=a;return;case ed:e=e.children;e=e(d._currentValue);Z(a,b,null,e);return;case kd:f=d._init;d=f(d._payload);e=Ee(d,e);Fe(a,b,c,d,e,void 0);return}throw Error(h(130,null==d?d:typeof d,""));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case Zc:Fe(a,b,c,d.type,d.props,d.ref);return;case $c:throw Error(h(257));case kd:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(ra(d)){Ie(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=sd&&d[sd]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=[];do e.push(d.value),d=c.next();while(!d.done);Ie(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,me(d));
+if(d.$$typeof===ed||d.$$typeof===fd)return Z(a,b,null,d._currentValue);a=Object.prototype.toString.call(d);throw Error(h(31,"[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a));}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=La(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}
+function Ie(a,b,c){for(var d=c.length,e=0;ea.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,
+a.completedBoundaries.push(d),tb(b,a.responseState,d.id),Ne(a,b,c);else{(c=a.resources.boundaryResources)&&d.resources.forEach(Yc,c);r(b,kb);c=d.completedSegments;if(1!==c.length)throw Error(h(391));Oe(a,b,c[0])}return r(b,ob)}function Pe(a,b,c){Pb(b,a.responseState,c.formatContext,c.id);Oe(a,b,c);return Qb(b,c.formatContext)}
+function Qe(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+function scheduleWork(callback) {
+ setImmediate(callback);
+}
+function flushBuffered(destination) {
+ // If we don't have any more data to send right now.
+ // Flush whatever is in the buffer to the wire.
+ if (typeof destination.flush === 'function') {
+ // By convention the Zlib streams provide a flush function for this purpose.
+ // For Express, compression middleware adds this method.
+ destination.flush();
+ }
+}
+new async_hooks.AsyncLocalStorage();
+var VIEW_SIZE = 2048;
+var currentView = null;
+var writtenBytes = 0;
+var destinationHasCapacity$1 = true;
+function beginWriting(destination) {
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ destinationHasCapacity$1 = true;
+}
+
+function writeStringChunk(destination, stringChunk) {
+ if (stringChunk.length === 0) {
+ return;
+ } // maximum possible view needed to encode entire string
+
+
+ if (stringChunk.length * 3 > VIEW_SIZE) {
+ if (writtenBytes > 0) {
+ writeToDestination(destination, currentView.subarray(0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ writeToDestination(destination, textEncoder.encode(stringChunk));
+ return;
+ }
+
+ var target = currentView;
+
+ if (writtenBytes > 0) {
+ target = currentView.subarray(writtenBytes);
+ }
+
+ var _textEncoder$encodeIn = textEncoder.encodeInto(stringChunk, target),
+ read = _textEncoder$encodeIn.read,
+ written = _textEncoder$encodeIn.written;
+
+ writtenBytes += written;
+
+ if (read < stringChunk.length) {
+ writeToDestination(destination, currentView.subarray(0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = textEncoder.encodeInto(stringChunk.slice(read), currentView).written;
+ }
+
+ if (writtenBytes === VIEW_SIZE) {
+ writeToDestination(destination, currentView);
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+}
+
+function writeViewChunk(destination, chunk) {
+ if (chunk.byteLength === 0) {
+ return;
+ }
+
+ if (chunk.byteLength > VIEW_SIZE) {
+ {
+ if (precomputedChunkSet && precomputedChunkSet.has(chunk)) {
+ error('A large precomputed chunk was passed to writeChunk without being copied.' + ' Large chunks get enqueued directly and are not copied. This is incompatible with precomputed chunks because you cannot enqueue the same precomputed chunk twice.' + ' Use "cloneChunk" to make a copy of this large precomputed chunk before writing it. This is a bug in React.');
+ }
+ } // this chunk may overflow a single view which implies it was not
+ // one that is cached by the streaming renderer. We will enqueu
+ // it directly and expect it is not re-used
+
+
+ if (writtenBytes > 0) {
+ writeToDestination(destination, currentView.subarray(0, writtenBytes));
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ writeToDestination(destination, chunk);
+ return;
+ }
+
+ var bytesToWrite = chunk;
+ var allowableBytes = currentView.length - writtenBytes;
+
+ if (allowableBytes < bytesToWrite.byteLength) {
+ // this chunk would overflow the current view. We enqueue a full view
+ // and start a new view with the remaining chunk
+ if (allowableBytes === 0) {
+ // the current view is already full, send it
+ writeToDestination(destination, currentView);
+ } else {
+ // fill up the current view and apply the remaining chunk bytes
+ // to a new view.
+ currentView.set(bytesToWrite.subarray(0, allowableBytes), writtenBytes);
+ writtenBytes += allowableBytes;
+ writeToDestination(destination, currentView);
+ bytesToWrite = bytesToWrite.subarray(allowableBytes);
+ }
+
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+
+ currentView.set(bytesToWrite, writtenBytes);
+ writtenBytes += bytesToWrite.byteLength;
+
+ if (writtenBytes === VIEW_SIZE) {
+ writeToDestination(destination, currentView);
+ currentView = new Uint8Array(VIEW_SIZE);
+ writtenBytes = 0;
+ }
+}
+
+function writeChunk(destination, chunk) {
+ if (typeof chunk === 'string') {
+ writeStringChunk(destination, chunk);
+ } else {
+ writeViewChunk(destination, chunk);
+ }
+}
+
+function writeToDestination(destination, view) {
+ var currentHasCapacity = destination.write(view);
+ destinationHasCapacity$1 = destinationHasCapacity$1 && currentHasCapacity;
+}
+
+function writeChunkAndReturn(destination, chunk) {
+ writeChunk(destination, chunk);
+ return destinationHasCapacity$1;
+}
+function completeWriting(destination) {
+ if (currentView && writtenBytes > 0) {
+ destination.write(currentView.subarray(0, writtenBytes));
+ }
+
+ currentView = null;
+ writtenBytes = 0;
+ destinationHasCapacity$1 = true;
+}
+function close(destination) {
+ destination.end();
+}
+var textEncoder = new util.TextEncoder();
+function stringToChunk(content) {
+ return content;
+}
+var precomputedChunkSet = new Set() ;
+function stringToPrecomputedChunk(content) {
+ var precomputedChunk = textEncoder.encode(content);
+
+ {
+ if (precomputedChunkSet) {
+ precomputedChunkSet.add(precomputedChunk);
+ }
+ }
+
+ return precomputedChunk;
+}
+function clonePrecomputedChunk(precomputedChunk) {
+ return precomputedChunk.length > VIEW_SIZE ? precomputedChunk.slice() : precomputedChunk;
+}
+function closeWithError(destination, error) {
+ // $FlowFixMe[incompatible-call]: This is an Error object or the destination accepts other types.
+ destination.destroy(error);
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+var assign = Object.assign;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+var enableFloat = true;
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+var unitlessNumbers = new Set(['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', // SVG-related properties
+'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'MozAnimationIterationCount', // Known Prefixed Properties
+'MozBoxFlex', // TODO: Remove these since they shouldn't be used in modern code
+'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']);
+function isUnitlessNumber (name) {
+ return unitlessNumbers.has(name);
+}
+
+var aliases = new Map([['acceptCharset', 'accept-charset'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv'], // HTML and SVG attributes, but the SVG attribute is case sensitive.],
+['crossOrigin', 'crossorigin'], // This is a list of all SVG attributes that need special casing.
+// Regular attributes that just accept strings.],
+['accentHeight', 'accent-height'], ['alignmentBaseline', 'alignment-baseline'], ['arabicForm', 'arabic-form'], ['baselineShift', 'baseline-shift'], ['capHeight', 'cap-height'], ['clipPath', 'clip-path'], ['clipRule', 'clip-rule'], ['colorInterpolation', 'color-interpolation'], ['colorInterpolationFilters', 'color-interpolation-filters'], ['colorProfile', 'color-profile'], ['colorRendering', 'color-rendering'], ['dominantBaseline', 'dominant-baseline'], ['enableBackground', 'enable-background'], ['fillOpacity', 'fill-opacity'], ['fillRule', 'fill-rule'], ['floodColor', 'flood-color'], ['floodOpacity', 'flood-opacity'], ['fontFamily', 'font-family'], ['fontSize', 'font-size'], ['fontSizeAdjust', 'font-size-adjust'], ['fontStretch', 'font-stretch'], ['fontStyle', 'font-style'], ['fontVariant', 'font-variant'], ['fontWeight', 'font-weight'], ['glyphName', 'glyph-name'], ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], ['glyphOrientationVertical', 'glyph-orientation-vertical'], ['horizAdvX', 'horiz-adv-x'], ['horizOriginX', 'horiz-origin-x'], ['imageRendering', 'image-rendering'], ['letterSpacing', 'letter-spacing'], ['lightingColor', 'lighting-color'], ['markerEnd', 'marker-end'], ['markerMid', 'marker-mid'], ['markerStart', 'marker-start'], ['overlinePosition', 'overline-position'], ['overlineThickness', 'overline-thickness'], ['paintOrder', 'paint-order'], ['panose-1', 'panose-1'], ['pointerEvents', 'pointer-events'], ['renderingIntent', 'rendering-intent'], ['shapeRendering', 'shape-rendering'], ['stopColor', 'stop-color'], ['stopOpacity', 'stop-opacity'], ['strikethroughPosition', 'strikethrough-position'], ['strikethroughThickness', 'strikethrough-thickness'], ['strokeDasharray', 'stroke-dasharray'], ['strokeDashoffset', 'stroke-dashoffset'], ['strokeLinecap', 'stroke-linecap'], ['strokeLinejoin', 'stroke-linejoin'], ['strokeMiterlimit', 'stroke-miterlimit'], ['strokeOpacity', 'stroke-opacity'], ['strokeWidth', 'stroke-width'], ['textAnchor', 'text-anchor'], ['textDecoration', 'text-decoration'], ['textRendering', 'text-rendering'], ['transformOrigin', 'transform-origin'], ['underlinePosition', 'underline-position'], ['underlineThickness', 'underline-thickness'], ['unicodeBidi', 'unicode-bidi'], ['unicodeRange', 'unicode-range'], ['unitsPerEm', 'units-per-em'], ['vAlphabetic', 'v-alphabetic'], ['vHanging', 'v-hanging'], ['vIdeographic', 'v-ideographic'], ['vMathematical', 'v-mathematical'], ['vectorEffect', 'vector-effect'], ['vertAdvY', 'vert-adv-y'], ['vertOriginX', 'vert-origin-x'], ['vertOriginY', 'vert-origin-y'], ['wordSpacing', 'word-spacing'], ['writingMode', 'writing-mode'], ['xmlnsXlink', 'xmlns:xlink'], ['xHeight', 'x-height']]);
+function getAttributeAlias (name) {
+ return aliases.get(name) || name;
+}
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+var ariaProperties = {
+ 'aria-current': 0,
+ // state
+ 'aria-description': 0,
+ 'aria-details': 0,
+ 'aria-disabled': 0,
+ // state
+ 'aria-hidden': 0,
+ // state
+ 'aria-invalid': 0,
+ // state
+ 'aria-keyshortcuts': 0,
+ 'aria-label': 0,
+ 'aria-roledescription': 0,
+ // Widget Attributes
+ 'aria-autocomplete': 0,
+ 'aria-checked': 0,
+ 'aria-expanded': 0,
+ 'aria-haspopup': 0,
+ 'aria-level': 0,
+ 'aria-modal': 0,
+ 'aria-multiline': 0,
+ 'aria-multiselectable': 0,
+ 'aria-orientation': 0,
+ 'aria-placeholder': 0,
+ 'aria-pressed': 0,
+ 'aria-readonly': 0,
+ 'aria-required': 0,
+ 'aria-selected': 0,
+ 'aria-sort': 0,
+ 'aria-valuemax': 0,
+ 'aria-valuemin': 0,
+ 'aria-valuenow': 0,
+ 'aria-valuetext': 0,
+ // Live Region Attributes
+ 'aria-atomic': 0,
+ 'aria-busy': 0,
+ 'aria-live': 0,
+ 'aria-relevant': 0,
+ // Drag-and-Drop Attributes
+ 'aria-dropeffect': 0,
+ 'aria-grabbed': 0,
+ // Relationship Attributes
+ 'aria-activedescendant': 0,
+ 'aria-colcount': 0,
+ 'aria-colindex': 0,
+ 'aria-colspan': 0,
+ 'aria-controls': 0,
+ 'aria-describedby': 0,
+ 'aria-errormessage': 0,
+ 'aria-flowto': 0,
+ 'aria-labelledby': 0,
+ 'aria-owns': 0,
+ 'aria-posinset': 0,
+ 'aria-rowcount': 0,
+ 'aria-rowindex': 0,
+ 'aria-rowspan': 0,
+ 'aria-setsize': 0
+};
+
+var warnedProperties$1 = {};
+var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');
+var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');
+
+function validateProperty$1(tagName, name) {
+ {
+ if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) {
+ return true;
+ }
+
+ if (rARIACamel$1.test(name)) {
+ var ariaName = 'aria-' + name.slice(4).toLowerCase();
+ var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (correctName == null) {
+ error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.', name);
+
+ warnedProperties$1[name] = true;
+ return true;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== correctName) {
+ error('Invalid ARIA attribute `%s`. Did you mean `%s`?', name, correctName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+
+ if (rARIA$1.test(name)) {
+ var lowerCasedName = name.toLowerCase();
+ var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null; // If this is an aria-* attribute, but is not listed in the known DOM
+ // DOM properties, then it is an invalid aria-* attribute.
+
+ if (standardName == null) {
+ warnedProperties$1[name] = true;
+ return false;
+ } // aria-* attributes should be lowercase; suggest the lowercase version.
+
+
+ if (name !== standardName) {
+ error('Unknown ARIA attribute `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties$1[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+}
+
+function validateProperties$2(type, props) {
+ {
+ var invalidProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty$1(type, key);
+
+ if (!isValid) {
+ invalidProps.push(key);
+ }
+ }
+
+ var unknownPropString = invalidProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (invalidProps.length === 1) {
+ error('Invalid aria prop %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ } else if (invalidProps.length > 1) {
+ error('Invalid aria props %s on <%s> tag. ' + 'For details, see https://reactjs.org/link/invalid-aria-props', unknownPropString, type);
+ }
+ }
+}
+
+var didWarnValueNull = false;
+function validateProperties$1(type, props) {
+ {
+ if (type !== 'input' && type !== 'textarea' && type !== 'select') {
+ return;
+ }
+
+ if (props != null && props.value === null && !didWarnValueNull) {
+ didWarnValueNull = true;
+
+ if (type === 'select' && props.multiple) {
+ 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);
+ } else {
+ error('`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.', type);
+ }
+ }
+ }
+}
+
+function isCustomElement(tagName, props) {
+ if (tagName.indexOf('-') === -1) {
+ return false;
+ }
+
+ switch (tagName) {
+ // These are reserved SVG and MathML elements.
+ // We don't mind this list too much because we expect it to never grow.
+ // The alternative is to track the namespace in a few places which is convoluted.
+ // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+ case 'annotation-xml':
+ case 'color-profile':
+ case 'font-face':
+ case 'font-face-src':
+ case 'font-face-uri':
+ case 'font-face-format':
+ case 'font-face-name':
+ case 'missing-glyph':
+ return false;
+
+ default:
+ return true;
+ }
+}
+
+// When adding attributes to the HTML or SVG allowed attribute list, be sure to
+// also add them to this module to ensure casing and incorrect name
+// warnings.
+var possibleStandardNames = {
+ // HTML
+ accept: 'accept',
+ acceptcharset: 'acceptCharset',
+ 'accept-charset': 'acceptCharset',
+ accesskey: 'accessKey',
+ action: 'action',
+ allowfullscreen: 'allowFullScreen',
+ alt: 'alt',
+ as: 'as',
+ async: 'async',
+ autocapitalize: 'autoCapitalize',
+ autocomplete: 'autoComplete',
+ autocorrect: 'autoCorrect',
+ autofocus: 'autoFocus',
+ autoplay: 'autoPlay',
+ autosave: 'autoSave',
+ capture: 'capture',
+ cellpadding: 'cellPadding',
+ cellspacing: 'cellSpacing',
+ challenge: 'challenge',
+ charset: 'charSet',
+ checked: 'checked',
+ children: 'children',
+ cite: 'cite',
+ class: 'className',
+ classid: 'classID',
+ classname: 'className',
+ cols: 'cols',
+ colspan: 'colSpan',
+ content: 'content',
+ contenteditable: 'contentEditable',
+ contextmenu: 'contextMenu',
+ controls: 'controls',
+ controlslist: 'controlsList',
+ coords: 'coords',
+ crossorigin: 'crossOrigin',
+ dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',
+ data: 'data',
+ datetime: 'dateTime',
+ default: 'default',
+ defaultchecked: 'defaultChecked',
+ defaultvalue: 'defaultValue',
+ defer: 'defer',
+ dir: 'dir',
+ disabled: 'disabled',
+ disablepictureinpicture: 'disablePictureInPicture',
+ disableremoteplayback: 'disableRemotePlayback',
+ download: 'download',
+ draggable: 'draggable',
+ enctype: 'encType',
+ enterkeyhint: 'enterKeyHint',
+ fetchpriority: 'fetchPriority',
+ for: 'htmlFor',
+ form: 'form',
+ formmethod: 'formMethod',
+ formaction: 'formAction',
+ formenctype: 'formEncType',
+ formnovalidate: 'formNoValidate',
+ formtarget: 'formTarget',
+ frameborder: 'frameBorder',
+ headers: 'headers',
+ height: 'height',
+ hidden: 'hidden',
+ high: 'high',
+ href: 'href',
+ hreflang: 'hrefLang',
+ htmlfor: 'htmlFor',
+ httpequiv: 'httpEquiv',
+ 'http-equiv': 'httpEquiv',
+ icon: 'icon',
+ id: 'id',
+ imagesizes: 'imageSizes',
+ imagesrcset: 'imageSrcSet',
+ innerhtml: 'innerHTML',
+ inputmode: 'inputMode',
+ integrity: 'integrity',
+ is: 'is',
+ itemid: 'itemID',
+ itemprop: 'itemProp',
+ itemref: 'itemRef',
+ itemscope: 'itemScope',
+ itemtype: 'itemType',
+ keyparams: 'keyParams',
+ keytype: 'keyType',
+ kind: 'kind',
+ label: 'label',
+ lang: 'lang',
+ list: 'list',
+ loop: 'loop',
+ low: 'low',
+ manifest: 'manifest',
+ marginwidth: 'marginWidth',
+ marginheight: 'marginHeight',
+ max: 'max',
+ maxlength: 'maxLength',
+ media: 'media',
+ mediagroup: 'mediaGroup',
+ method: 'method',
+ min: 'min',
+ minlength: 'minLength',
+ multiple: 'multiple',
+ muted: 'muted',
+ name: 'name',
+ nomodule: 'noModule',
+ nonce: 'nonce',
+ novalidate: 'noValidate',
+ open: 'open',
+ optimum: 'optimum',
+ pattern: 'pattern',
+ placeholder: 'placeholder',
+ playsinline: 'playsInline',
+ poster: 'poster',
+ preload: 'preload',
+ profile: 'profile',
+ radiogroup: 'radioGroup',
+ readonly: 'readOnly',
+ referrerpolicy: 'referrerPolicy',
+ rel: 'rel',
+ required: 'required',
+ reversed: 'reversed',
+ role: 'role',
+ rows: 'rows',
+ rowspan: 'rowSpan',
+ sandbox: 'sandbox',
+ scope: 'scope',
+ scoped: 'scoped',
+ scrolling: 'scrolling',
+ seamless: 'seamless',
+ selected: 'selected',
+ shape: 'shape',
+ size: 'size',
+ sizes: 'sizes',
+ span: 'span',
+ spellcheck: 'spellCheck',
+ src: 'src',
+ srcdoc: 'srcDoc',
+ srclang: 'srcLang',
+ srcset: 'srcSet',
+ start: 'start',
+ step: 'step',
+ style: 'style',
+ summary: 'summary',
+ tabindex: 'tabIndex',
+ target: 'target',
+ title: 'title',
+ type: 'type',
+ usemap: 'useMap',
+ value: 'value',
+ width: 'width',
+ wmode: 'wmode',
+ wrap: 'wrap',
+ // SVG
+ about: 'about',
+ accentheight: 'accentHeight',
+ 'accent-height': 'accentHeight',
+ accumulate: 'accumulate',
+ additive: 'additive',
+ alignmentbaseline: 'alignmentBaseline',
+ 'alignment-baseline': 'alignmentBaseline',
+ allowreorder: 'allowReorder',
+ alphabetic: 'alphabetic',
+ amplitude: 'amplitude',
+ arabicform: 'arabicForm',
+ 'arabic-form': 'arabicForm',
+ ascent: 'ascent',
+ attributename: 'attributeName',
+ attributetype: 'attributeType',
+ autoreverse: 'autoReverse',
+ azimuth: 'azimuth',
+ basefrequency: 'baseFrequency',
+ baselineshift: 'baselineShift',
+ 'baseline-shift': 'baselineShift',
+ baseprofile: 'baseProfile',
+ bbox: 'bbox',
+ begin: 'begin',
+ bias: 'bias',
+ by: 'by',
+ calcmode: 'calcMode',
+ capheight: 'capHeight',
+ 'cap-height': 'capHeight',
+ clip: 'clip',
+ clippath: 'clipPath',
+ 'clip-path': 'clipPath',
+ clippathunits: 'clipPathUnits',
+ cliprule: 'clipRule',
+ 'clip-rule': 'clipRule',
+ color: 'color',
+ colorinterpolation: 'colorInterpolation',
+ 'color-interpolation': 'colorInterpolation',
+ colorinterpolationfilters: 'colorInterpolationFilters',
+ 'color-interpolation-filters': 'colorInterpolationFilters',
+ colorprofile: 'colorProfile',
+ 'color-profile': 'colorProfile',
+ colorrendering: 'colorRendering',
+ 'color-rendering': 'colorRendering',
+ contentscripttype: 'contentScriptType',
+ contentstyletype: 'contentStyleType',
+ cursor: 'cursor',
+ cx: 'cx',
+ cy: 'cy',
+ d: 'd',
+ datatype: 'datatype',
+ decelerate: 'decelerate',
+ descent: 'descent',
+ diffuseconstant: 'diffuseConstant',
+ direction: 'direction',
+ display: 'display',
+ divisor: 'divisor',
+ dominantbaseline: 'dominantBaseline',
+ 'dominant-baseline': 'dominantBaseline',
+ dur: 'dur',
+ dx: 'dx',
+ dy: 'dy',
+ edgemode: 'edgeMode',
+ elevation: 'elevation',
+ enablebackground: 'enableBackground',
+ 'enable-background': 'enableBackground',
+ end: 'end',
+ exponent: 'exponent',
+ externalresourcesrequired: 'externalResourcesRequired',
+ fill: 'fill',
+ fillopacity: 'fillOpacity',
+ 'fill-opacity': 'fillOpacity',
+ fillrule: 'fillRule',
+ 'fill-rule': 'fillRule',
+ filter: 'filter',
+ filterres: 'filterRes',
+ filterunits: 'filterUnits',
+ floodopacity: 'floodOpacity',
+ 'flood-opacity': 'floodOpacity',
+ floodcolor: 'floodColor',
+ 'flood-color': 'floodColor',
+ focusable: 'focusable',
+ fontfamily: 'fontFamily',
+ 'font-family': 'fontFamily',
+ fontsize: 'fontSize',
+ 'font-size': 'fontSize',
+ fontsizeadjust: 'fontSizeAdjust',
+ 'font-size-adjust': 'fontSizeAdjust',
+ fontstretch: 'fontStretch',
+ 'font-stretch': 'fontStretch',
+ fontstyle: 'fontStyle',
+ 'font-style': 'fontStyle',
+ fontvariant: 'fontVariant',
+ 'font-variant': 'fontVariant',
+ fontweight: 'fontWeight',
+ 'font-weight': 'fontWeight',
+ format: 'format',
+ from: 'from',
+ fx: 'fx',
+ fy: 'fy',
+ g1: 'g1',
+ g2: 'g2',
+ glyphname: 'glyphName',
+ 'glyph-name': 'glyphName',
+ glyphorientationhorizontal: 'glyphOrientationHorizontal',
+ 'glyph-orientation-horizontal': 'glyphOrientationHorizontal',
+ glyphorientationvertical: 'glyphOrientationVertical',
+ 'glyph-orientation-vertical': 'glyphOrientationVertical',
+ glyphref: 'glyphRef',
+ gradienttransform: 'gradientTransform',
+ gradientunits: 'gradientUnits',
+ hanging: 'hanging',
+ horizadvx: 'horizAdvX',
+ 'horiz-adv-x': 'horizAdvX',
+ horizoriginx: 'horizOriginX',
+ 'horiz-origin-x': 'horizOriginX',
+ ideographic: 'ideographic',
+ imagerendering: 'imageRendering',
+ 'image-rendering': 'imageRendering',
+ in2: 'in2',
+ in: 'in',
+ inlist: 'inlist',
+ intercept: 'intercept',
+ k1: 'k1',
+ k2: 'k2',
+ k3: 'k3',
+ k4: 'k4',
+ k: 'k',
+ kernelmatrix: 'kernelMatrix',
+ kernelunitlength: 'kernelUnitLength',
+ kerning: 'kerning',
+ keypoints: 'keyPoints',
+ keysplines: 'keySplines',
+ keytimes: 'keyTimes',
+ lengthadjust: 'lengthAdjust',
+ letterspacing: 'letterSpacing',
+ 'letter-spacing': 'letterSpacing',
+ lightingcolor: 'lightingColor',
+ 'lighting-color': 'lightingColor',
+ limitingconeangle: 'limitingConeAngle',
+ local: 'local',
+ markerend: 'markerEnd',
+ 'marker-end': 'markerEnd',
+ markerheight: 'markerHeight',
+ markermid: 'markerMid',
+ 'marker-mid': 'markerMid',
+ markerstart: 'markerStart',
+ 'marker-start': 'markerStart',
+ markerunits: 'markerUnits',
+ markerwidth: 'markerWidth',
+ mask: 'mask',
+ maskcontentunits: 'maskContentUnits',
+ maskunits: 'maskUnits',
+ mathematical: 'mathematical',
+ mode: 'mode',
+ numoctaves: 'numOctaves',
+ offset: 'offset',
+ opacity: 'opacity',
+ operator: 'operator',
+ order: 'order',
+ orient: 'orient',
+ orientation: 'orientation',
+ origin: 'origin',
+ overflow: 'overflow',
+ overlineposition: 'overlinePosition',
+ 'overline-position': 'overlinePosition',
+ overlinethickness: 'overlineThickness',
+ 'overline-thickness': 'overlineThickness',
+ paintorder: 'paintOrder',
+ 'paint-order': 'paintOrder',
+ panose1: 'panose1',
+ 'panose-1': 'panose1',
+ pathlength: 'pathLength',
+ patterncontentunits: 'patternContentUnits',
+ patterntransform: 'patternTransform',
+ patternunits: 'patternUnits',
+ pointerevents: 'pointerEvents',
+ 'pointer-events': 'pointerEvents',
+ points: 'points',
+ pointsatx: 'pointsAtX',
+ pointsaty: 'pointsAtY',
+ pointsatz: 'pointsAtZ',
+ prefix: 'prefix',
+ preservealpha: 'preserveAlpha',
+ preserveaspectratio: 'preserveAspectRatio',
+ primitiveunits: 'primitiveUnits',
+ property: 'property',
+ r: 'r',
+ radius: 'radius',
+ refx: 'refX',
+ refy: 'refY',
+ renderingintent: 'renderingIntent',
+ 'rendering-intent': 'renderingIntent',
+ repeatcount: 'repeatCount',
+ repeatdur: 'repeatDur',
+ requiredextensions: 'requiredExtensions',
+ requiredfeatures: 'requiredFeatures',
+ resource: 'resource',
+ restart: 'restart',
+ result: 'result',
+ results: 'results',
+ rotate: 'rotate',
+ rx: 'rx',
+ ry: 'ry',
+ scale: 'scale',
+ security: 'security',
+ seed: 'seed',
+ shaperendering: 'shapeRendering',
+ 'shape-rendering': 'shapeRendering',
+ slope: 'slope',
+ spacing: 'spacing',
+ specularconstant: 'specularConstant',
+ specularexponent: 'specularExponent',
+ speed: 'speed',
+ spreadmethod: 'spreadMethod',
+ startoffset: 'startOffset',
+ stddeviation: 'stdDeviation',
+ stemh: 'stemh',
+ stemv: 'stemv',
+ stitchtiles: 'stitchTiles',
+ stopcolor: 'stopColor',
+ 'stop-color': 'stopColor',
+ stopopacity: 'stopOpacity',
+ 'stop-opacity': 'stopOpacity',
+ strikethroughposition: 'strikethroughPosition',
+ 'strikethrough-position': 'strikethroughPosition',
+ strikethroughthickness: 'strikethroughThickness',
+ 'strikethrough-thickness': 'strikethroughThickness',
+ string: 'string',
+ stroke: 'stroke',
+ strokedasharray: 'strokeDasharray',
+ 'stroke-dasharray': 'strokeDasharray',
+ strokedashoffset: 'strokeDashoffset',
+ 'stroke-dashoffset': 'strokeDashoffset',
+ strokelinecap: 'strokeLinecap',
+ 'stroke-linecap': 'strokeLinecap',
+ strokelinejoin: 'strokeLinejoin',
+ 'stroke-linejoin': 'strokeLinejoin',
+ strokemiterlimit: 'strokeMiterlimit',
+ 'stroke-miterlimit': 'strokeMiterlimit',
+ strokewidth: 'strokeWidth',
+ 'stroke-width': 'strokeWidth',
+ strokeopacity: 'strokeOpacity',
+ 'stroke-opacity': 'strokeOpacity',
+ suppresscontenteditablewarning: 'suppressContentEditableWarning',
+ suppresshydrationwarning: 'suppressHydrationWarning',
+ surfacescale: 'surfaceScale',
+ systemlanguage: 'systemLanguage',
+ tablevalues: 'tableValues',
+ targetx: 'targetX',
+ targety: 'targetY',
+ textanchor: 'textAnchor',
+ 'text-anchor': 'textAnchor',
+ textdecoration: 'textDecoration',
+ 'text-decoration': 'textDecoration',
+ textlength: 'textLength',
+ textrendering: 'textRendering',
+ 'text-rendering': 'textRendering',
+ to: 'to',
+ transform: 'transform',
+ transformorigin: 'transformOrigin',
+ 'transform-origin': 'transformOrigin',
+ typeof: 'typeof',
+ u1: 'u1',
+ u2: 'u2',
+ underlineposition: 'underlinePosition',
+ 'underline-position': 'underlinePosition',
+ underlinethickness: 'underlineThickness',
+ 'underline-thickness': 'underlineThickness',
+ unicode: 'unicode',
+ unicodebidi: 'unicodeBidi',
+ 'unicode-bidi': 'unicodeBidi',
+ unicoderange: 'unicodeRange',
+ 'unicode-range': 'unicodeRange',
+ unitsperem: 'unitsPerEm',
+ 'units-per-em': 'unitsPerEm',
+ unselectable: 'unselectable',
+ valphabetic: 'vAlphabetic',
+ 'v-alphabetic': 'vAlphabetic',
+ values: 'values',
+ vectoreffect: 'vectorEffect',
+ 'vector-effect': 'vectorEffect',
+ version: 'version',
+ vertadvy: 'vertAdvY',
+ 'vert-adv-y': 'vertAdvY',
+ vertoriginx: 'vertOriginX',
+ 'vert-origin-x': 'vertOriginX',
+ vertoriginy: 'vertOriginY',
+ 'vert-origin-y': 'vertOriginY',
+ vhanging: 'vHanging',
+ 'v-hanging': 'vHanging',
+ videographic: 'vIdeographic',
+ 'v-ideographic': 'vIdeographic',
+ viewbox: 'viewBox',
+ viewtarget: 'viewTarget',
+ visibility: 'visibility',
+ vmathematical: 'vMathematical',
+ 'v-mathematical': 'vMathematical',
+ vocab: 'vocab',
+ widths: 'widths',
+ wordspacing: 'wordSpacing',
+ 'word-spacing': 'wordSpacing',
+ writingmode: 'writingMode',
+ 'writing-mode': 'writingMode',
+ x1: 'x1',
+ x2: 'x2',
+ x: 'x',
+ xchannelselector: 'xChannelSelector',
+ xheight: 'xHeight',
+ 'x-height': 'xHeight',
+ xlinkactuate: 'xlinkActuate',
+ 'xlink:actuate': 'xlinkActuate',
+ xlinkarcrole: 'xlinkArcrole',
+ 'xlink:arcrole': 'xlinkArcrole',
+ xlinkhref: 'xlinkHref',
+ 'xlink:href': 'xlinkHref',
+ xlinkrole: 'xlinkRole',
+ 'xlink:role': 'xlinkRole',
+ xlinkshow: 'xlinkShow',
+ 'xlink:show': 'xlinkShow',
+ xlinktitle: 'xlinkTitle',
+ 'xlink:title': 'xlinkTitle',
+ xlinktype: 'xlinkType',
+ 'xlink:type': 'xlinkType',
+ xmlbase: 'xmlBase',
+ 'xml:base': 'xmlBase',
+ xmllang: 'xmlLang',
+ 'xml:lang': 'xmlLang',
+ xmlns: 'xmlns',
+ 'xml:space': 'xmlSpace',
+ xmlnsxlink: 'xmlnsXlink',
+ 'xmlns:xlink': 'xmlnsXlink',
+ xmlspace: 'xmlSpace',
+ y1: 'y1',
+ y2: 'y2',
+ y: 'y',
+ ychannelselector: 'yChannelSelector',
+ z: 'z',
+ zoomandpan: 'zoomAndPan'
+};
+
+var warnedProperties = {};
+var EVENT_NAME_REGEX = /^on./;
+var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
+var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$') ;
+
+function validateProperty(tagName, name, value, eventRegistry) {
+ {
+ if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
+ return true;
+ }
+
+ var lowerCasedName = name.toLowerCase();
+
+ if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {
+ 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.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ {
+ // Actions are special because unlike events they can have other value types.
+ if (typeof value === 'function') {
+ if (tagName === 'form' && name === 'action') {
+ return true;
+ }
+
+ if (tagName === 'input' && name === 'formAction') {
+ return true;
+ }
+
+ if (tagName === 'button' && name === 'formAction') {
+ return true;
+ }
+ }
+ } // We can't rely on the event system being injected on the server.
+
+
+ if (eventRegistry != null) {
+ var registrationNameDependencies = eventRegistry.registrationNameDependencies,
+ possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
+
+ if (registrationNameDependencies.hasOwnProperty(name)) {
+ return true;
+ }
+
+ var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
+
+ if (registrationName != null) {
+ error('Invalid event handler property `%s`. Did you mean `%s`?', name, registrationName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (EVENT_NAME_REGEX.test(name)) {
+ error('Unknown event handler property `%s`. It will be ignored.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (EVENT_NAME_REGEX.test(name)) {
+ // If no event plugins have been injected, we are in a server environment.
+ // So we can't tell if the event name is correct for sure, but we can filter
+ // out known bad ones like `onclick`. We can't suggest a specific replacement though.
+ if (INVALID_EVENT_NAME_REGEX.test(name)) {
+ error('Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.', name);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ } // Let the ARIA attribute hook validate ARIA attributes
+
+
+ if (rARIA.test(name) || rARIACamel.test(name)) {
+ return true;
+ }
+
+ if (lowerCasedName === 'innerhtml') {
+ error('Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'aria') {
+ error('The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {
+ error('Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.', typeof value);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+
+ if (typeof value === 'number' && isNaN(value)) {
+ error('Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.', name);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Known attributes should match the casing specified in the property config.
+
+
+ if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+ var standardName = possibleStandardNames[lowerCasedName];
+
+ if (standardName !== name) {
+ error('Invalid DOM property `%s`. Did you mean `%s`?', name, standardName);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ } else if (name !== lowerCasedName) {
+ // Unknown attributes should have lowercase casing since that's how they
+ // will be cased anyway with server rendering.
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ } // Now that we've validated casing, do not validate
+ // data types for reserved props
+
+
+ switch (name) {
+ case 'dangerouslySetInnerHTML':
+ case 'children':
+ case 'style':
+ case 'suppressContentEditableWarning':
+ case 'suppressHydrationWarning':
+ case 'defaultValue': // Reserved
+
+ case 'defaultChecked':
+ case 'innerHTML':
+ {
+ return true;
+ }
+
+ case 'innerText': // Properties
+
+ case 'textContent':
+ {
+ return true;
+ }
+
+ }
+
+ switch (typeof value) {
+ case 'boolean':
+ {
+ switch (name) {
+ case 'autoFocus':
+ case 'checked':
+ case 'multiple':
+ case 'muted':
+ case 'selected':
+ case 'contentEditable':
+ case 'spellCheck':
+ case 'draggable':
+ case 'value':
+ case 'autoReverse':
+ case 'externalResourcesRequired':
+ case 'focusable':
+ case 'preserveAlpha':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ case 'capture':
+ case 'download':
+ {
+ // Boolean properties can accept boolean values
+ return true;
+ }
+
+ default:
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix === 'data-' || prefix === 'aria-') {
+ return true;
+ }
+
+ if (value) {
+ 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);
+ } else {
+ 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);
+ }
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ // Warn when a known attribute is a bad type
+ warnedProperties[name] = true;
+ return false;
+
+ case 'string':
+ {
+ // Warn when passing the strings 'false' or 'true' into a boolean prop
+ if (value === 'false' || value === 'true') {
+ switch (name) {
+ case 'checked':
+ case 'selected':
+ case 'multiple':
+ case 'muted':
+ case 'allowFullScreen':
+ case 'async':
+ case 'autoPlay':
+ case 'controls':
+ case 'default':
+ case 'defer':
+ case 'disabled':
+ case 'disablePictureInPicture':
+ case 'disableRemotePlayback':
+ case 'formNoValidate':
+ case 'hidden':
+ case 'loop':
+ case 'noModule':
+ case 'noValidate':
+ case 'open':
+ case 'playsInline':
+ case 'readOnly':
+ case 'required':
+ case 'reversed':
+ case 'scoped':
+ case 'seamless':
+ case 'itemScope':
+ {
+ break;
+ }
+
+ default:
+ {
+ return true;
+ }
+ }
+
+ 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);
+
+ warnedProperties[name] = true;
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+function warnUnknownProperties(type, props, eventRegistry) {
+ {
+ var unknownProps = [];
+
+ for (var key in props) {
+ var isValid = validateProperty(type, key, props[key], eventRegistry);
+
+ if (!isValid) {
+ unknownProps.push(key);
+ }
+ }
+
+ var unknownPropString = unknownProps.map(function (prop) {
+ return '`' + prop + '`';
+ }).join(', ');
+
+ if (unknownProps.length === 1) {
+ 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);
+ } else if (unknownProps.length > 1) {
+ 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);
+ }
+ }
+}
+
+function validateProperties(type, props, eventRegistry) {
+ if (isCustomElement(type) || typeof props.is === 'string') {
+ return;
+ }
+
+ warnUnknownProperties(type, props, eventRegistry);
+}
+
+// 'msTransform' is correct, but the other prefixes should be capitalized
+var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+var msPattern$1 = /^-ms-/;
+var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
+
+var badStyleValueWithSemicolonPattern = /;\s*$/;
+var warnedStyleNames = {};
+var warnedStyleValues = {};
+var warnedForNaNValue = false;
+var warnedForInfinityValue = false;
+
+function camelize(string) {
+ return string.replace(hyphenPattern, function (_, character) {
+ return character.toUpperCase();
+ });
+}
+
+function warnHyphenatedStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
+ // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+ // is converted to lowercase `ms`.
+ camelize(name.replace(msPattern$1, 'ms-')));
+ }
+}
+
+function warnBadVendoredStyleName(name) {
+ {
+ if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+ return;
+ }
+
+ warnedStyleNames[name] = true;
+
+ error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
+ }
+}
+
+function warnStyleValueWithSemicolon(name, value) {
+ {
+ if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+ return;
+ }
+
+ warnedStyleValues[value] = true;
+
+ error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
+ }
+}
+
+function warnStyleValueIsNaN(name, value) {
+ {
+ if (warnedForNaNValue) {
+ return;
+ }
+
+ warnedForNaNValue = true;
+
+ error('`NaN` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnStyleValueIsInfinity(name, value) {
+ {
+ if (warnedForInfinityValue) {
+ return;
+ }
+
+ warnedForInfinityValue = true;
+
+ error('`Infinity` is an invalid value for the `%s` css style property.', name);
+ }
+}
+
+function warnValidStyle(name, value) {
+ {
+ if (name.indexOf('-') > -1) {
+ warnHyphenatedStyleName(name);
+ } else if (badVendoredStyleNamePattern.test(name)) {
+ warnBadVendoredStyleName(name);
+ } else if (badStyleValueWithSemicolonPattern.test(value)) {
+ warnStyleValueWithSemicolon(name, value);
+ }
+
+ if (typeof value === 'number') {
+ if (isNaN(value)) {
+ warnStyleValueIsNaN(name);
+ } else if (!isFinite(value)) {
+ warnStyleValueIsInfinity(name);
+ }
+ }
+ }
+}
+
+// code copied and modified from escape-html
+var matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes special characters and HTML entities in a given html string.
+ *
+ * @param {string} string HTML string to escape for later insertion
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml(string) {
+ {
+ checkHtmlStringCoercion(string);
+ }
+
+ var str = '' + string;
+ var match = matchHtmlRegExp.exec(str);
+
+ if (!match) {
+ return str;
+ }
+
+ var escape;
+ var html = '';
+ var index;
+ var lastIndex = 0;
+
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ // "
+ escape = '"';
+ break;
+
+ case 38:
+ // &
+ escape = '&';
+ break;
+
+ case 39:
+ // '
+ escape = '''; // modified from escape-html; used to be '''
+
+ break;
+
+ case 60:
+ // <
+ escape = '<';
+ break;
+
+ case 62:
+ // >
+ escape = '>';
+ break;
+
+ default:
+ continue;
+ }
+
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+
+ lastIndex = index + 1;
+ html += escape;
+ }
+
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+} // end code copied and modified from escape-html
+
+/**
+ * Escapes text to prevent scripting attacks.
+ *
+ * @param {*} text Text value to escape.
+ * @return {string} An escaped string.
+ */
+
+
+function escapeTextForBrowser(text) {
+ if (typeof text === 'boolean' || typeof text === 'number') {
+ // this shortcircuit helps perf for types that we know will never have
+ // special characters, especially given that this function is used often
+ // for numeric dom ids.
+ return '' + text;
+ }
+
+ return escapeHtml(text);
+}
+
+var uppercasePattern = /([A-Z])/g;
+var msPattern = /^ms-/;
+/**
+ * Hyphenates a camelcased CSS property name, for example:
+ *
+ * > hyphenateStyleName('backgroundColor')
+ * < "background-color"
+ * > hyphenateStyleName('MozTransition')
+ * < "-moz-transition"
+ * > hyphenateStyleName('msTransition')
+ * < "-ms-transition"
+ *
+ * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+ * is converted to `-ms-`.
+ */
+
+function hyphenateStyleName(name) {
+ return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
+}
+
+// and any newline or tab are filtered out as if they're not part of the URL.
+// https://url.spec.whatwg.org/#url-parsing
+// Tab or newline are defined as \r\n\t:
+// https://infra.spec.whatwg.org/#ascii-tab-or-newline
+// A C0 control is a code point in the range \u0000 NULL to \u001F
+// INFORMATION SEPARATOR ONE, inclusive:
+// https://infra.spec.whatwg.org/#c0-control-or-space
+
+/* eslint-disable max-len */
+
+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;
+var didWarn = false;
+
+function sanitizeURL(url) {
+ // We should never have symbols here because they get filtered out elsewhere.
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ var stringifiedURL = '' + url;
+
+ {
+ if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
+ didWarn = true;
+
+ 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(stringifiedURL));
+ }
+ }
+
+ return url;
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+ return isArrayImpl(a);
+}
+
+// The build script is at scripts/rollup/generate-inline-fizz-runtime.js.
+// Run `yarn generate-inline-fizz-runtime` to generate.
+var clientRenderBoundary = '$RX=function(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())};';
+var completeBoundary = '$RC=function(b,c,e){c=document.getElementById(c);c.parentNode.removeChild(c);var a=document.getElementById(b);if(a){b=a.previousSibling;if(e)b.data="$!",a.setAttribute("data-dgst",e);else{e=b.parentNode;a=b.nextSibling;var f=0;do{if(a&&8===a.nodeType){var d=a.data;if("/$"===d)if(0===f)break;else f--;else"$"!==d&&"$?"!==d&&"$!"!==d||f++}d=a.nextSibling;e.removeChild(a);a=d}while(a);for(;c.firstChild;)e.insertBefore(c.firstChild,a);b.data="$"}b._reactRetry&&b._reactRetry()}};';
+var completeBoundaryWithStyles = '$RM=new Map;\n$RR=function(r,t,w){for(var u=$RC,n=$RM,p=new Map,q=document,g,b,h=q.querySelectorAll("link[data-precedence],style[data-precedence]"),v=[],k=0;b=h[k++];)"not all"===b.getAttribute("media")?v.push(b):("LINK"===b.tagName&&n.set(b.getAttribute("href"),b),p.set(b.dataset.precedence,g=b));b=0;h=[];var l,a;for(k=!0;;){if(k){var f=w[b++];if(!f){k=!1;b=0;continue}var c=!1,m=0;var d=f[m++];if(a=n.get(d)){var e=a._p;c=!0}else{a=q.createElement("link");a.href=d;a.rel="stylesheet";for(a.dataset.precedence=\nl=f[m++];e=f[m++];)a.setAttribute(e,f[m++]);e=a._p=new Promise(function(x,y){a.onload=x;a.onerror=y});n.set(d,a)}d=a.getAttribute("media");!e||"l"===e.s||d&&!matchMedia(d).matches||h.push(e);if(c)continue}else{a=v[b++];if(!a)break;l=a.getAttribute("data-precedence");a.removeAttribute("media")}c=p.get(l)||g;c===g&&(g=a);p.set(l,a);c?c.parentNode.insertBefore(a,c.nextSibling):(c=q.head,c.insertBefore(a,c.firstChild))}Promise.all(h).then(u.bind(null,r,t,""),u.bind(null,r,t,"Resource failed to load"))};';
+var completeSegment = '$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)};';
+
+function getValueDescriptorExpectingObjectForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : "something with type \"" + typeof thing + "\"";
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+ return thing === null ? '`null`' : thing === undefined ? '`undefined`' : thing === '' ? 'an empty string' : typeof thing === 'string' ? JSON.stringify(thing) : "something with type \"" + typeof thing + "\"";
+}
+
+function compareResourcePropsForWarning(newProps, currentProps) {
+ {
+ var propDiffs = null;
+ var allProps = Array.from(new Set(Object.keys(currentProps).concat(Object.keys(newProps))));
+
+ for (var i = 0; i < allProps.length; i++) {
+ var propName = allProps[i];
+ var newValue = newProps[propName];
+ var currentValue = currentProps[propName];
+
+ if (newValue !== currentValue && !(newValue == null && currentValue == null)) {
+ if (newValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.missing[propName] = currentValue;
+ } else if (currentValue == null) {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.extra[propName] = newValue;
+ } else {
+ if (propDiffs === null) {
+ propDiffs = {
+ missing: {},
+ extra: {},
+ different: {}
+ };
+ }
+
+ propDiffs.different[propName] = {
+ original: currentValue,
+ latest: newValue
+ };
+ }
+ }
+ }
+
+ return propDiffs;
+ }
+}
+
+function describeDifferencesForStylesheets(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'media') {
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName in diff.extra) {
+ var _propValue = diff.extra[_propName];
+ description += "\n \"" + _propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue) + ", missing from original props";
+ }
+
+ for (var _propName2 in diff.different) {
+ var latestValue = diff.different[_propName2].latest;
+ var originalValue = diff.different[_propName2].original;
+ description += "\n \"" + _propName2 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForStylesheetOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'precedence' || propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName3 in diff.different) {
+ var latestValue = diff.different[_propName3].latest;
+ var originalValue = diff.different[_propName3].original;
+
+ if (_propName3 === 'precedence' && originalValue === 'default') {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", missing from options";
+ } else {
+ description += "\n \"" + _propName3 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverStylesheet(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName4 in diff.extra) {
+ var _propValue2 = diff.extra[_propName4];
+
+ if (_propName4 === 'precedence' || _propName4 === 'crossOrigin' || _propName4 === 'integrity') {
+ description += "\n \"" + _propName4 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue2) + ", missing from props";
+ }
+ }
+
+ for (var _propName5 in diff.different) {
+ var latestValue = diff.different[_propName5].latest;
+ var originalValue = diff.different[_propName5].original;
+ description += "\n \"" + _propName5 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinits(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (propName === 'precedence' && propValue !== 'default') {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName6 in diff.extra) {
+ var _propValue3 = diff.extra[_propName6];
+
+ if (_propName6 === 'precedence' && _propValue3 !== 'default' || _propName6 === 'crossOrigin' || _propName6 === 'integrity') {
+ description += "\n \"" + _propName6 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue3) + ", missing from original options";
+ }
+ }
+
+ for (var _propName7 in diff.different) {
+ var latestValue = diff.different[_propName7].latest;
+ var originalValue = diff.different[_propName7].original;
+ description += "\n \"" + _propName7 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+var preloadOptionsForComparison = ['as', 'crossOrigin', 'integrity', 'media'];
+function describeDifferencesForPreloads(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, original option value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName8 in diff.extra) {
+ var _propValue4 = diff.extra[_propName8];
+
+ if (preloadOptionsForComparison.includes(_propName8)) {
+ description += "\n \"" + _propName8 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue4) + ", missing from original options";
+ }
+ }
+
+ for (var _propName9 in diff.different) {
+ var latestValue = diff.different[_propName9].latest;
+ var originalValue = diff.different[_propName9].original;
+
+ if (preloadOptionsForComparison.includes(_propName9)) {
+ description += "\n \"" + _propName9 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForPreloadOverImplicitPreload(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+
+ if (preloadOptionsForComparison.includes(propName)) {
+ description += "\n \"" + propName + "\" missing from options, underlying prop value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+ }
+
+ for (var _propName10 in diff.extra) {
+ var _propValue5 = diff.extra[_propName10];
+
+ if (preloadOptionsForComparison.includes(_propName10)) {
+ description += "\n \"" + _propName10 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(_propValue5) + ", missing from underlying props";
+ }
+ }
+
+ for (var _propName11 in diff.different) {
+ var latestValue = diff.different[_propName11].latest;
+ var originalValue = diff.different[_propName11].original;
+
+ if (preloadOptionsForComparison.includes(_propName11)) {
+ description += "\n \"" + _propName11 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", underlying prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+ }
+
+ return description;
+}
+function describeDifferencesForScripts(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.missing) {
+ var propValue = diff.missing[propName];
+ description += "\n \"" + propName + "\" missing for props, original value: " + getValueDescriptorExpectingEnumForWarning(propValue);
+ }
+
+ for (var _propName12 in diff.extra) {
+ var _propValue6 = diff.extra[_propName12];
+ description += "\n \"" + _propName12 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(_propValue6) + ", missing from original props";
+ }
+
+ for (var _propName13 in diff.different) {
+ var latestValue = diff.different[_propName13].latest;
+ var originalValue = diff.different[_propName13].original;
+ description += "\n \"" + _propName13 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", original value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForScriptOverPreinit(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option missing";
+ } else {
+ description += "\n \"" + propName + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", option not available with ReactDOM.preinit()";
+ }
+ }
+
+ for (var _propName14 in diff.different) {
+ var latestValue = diff.different[_propName14].latest;
+ var originalValue = diff.different[_propName14].original;
+ description += "\n \"" + _propName14 + "\" prop value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", option value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+function describeDifferencesForPreinitOverScript(newProps, currentProps) {
+ var diff = compareResourcePropsForWarning(newProps, currentProps);
+ if (!diff) return '';
+ var description = '';
+
+ for (var propName in diff.extra) {
+ var propValue = diff.extra[propName];
+
+ if (propName === 'crossOrigin' || propName === 'integrity') {
+ description += "\n \"" + propName + "\" option value: " + getValueDescriptorExpectingEnumForWarning(propValue) + ", missing from props";
+ }
+ }
+
+ for (var _propName15 in diff.different) {
+ var latestValue = diff.different[_propName15].latest;
+ var originalValue = diff.different[_propName15].original;
+ description += "\n \"" + _propName15 + "\" option value: " + getValueDescriptorExpectingEnumForWarning(latestValue) + ", prop value: " + getValueDescriptorExpectingEnumForWarning(originalValue);
+ }
+
+ return description;
+}
+
+var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
+var ReactDOMServerDispatcher = {
+ prefetchDNS: prefetchDNS,
+ preconnect: preconnect,
+ preload: preload,
+ preinit: preinit
+} ;
+var currentResources = null;
+var currentResourcesStack = [];
+function prepareToRender(resources) {
+ currentResourcesStack.push(currentResources);
+ currentResources = resources;
+ var previousHostDispatcher = ReactDOMCurrentDispatcher.current;
+ ReactDOMCurrentDispatcher.current = ReactDOMServerDispatcher;
+ return previousHostDispatcher;
+}
+function cleanupAfterRender(previousDispatcher) {
+ currentResources = currentResourcesStack.pop();
+ ReactDOMCurrentDispatcher.current = previousDispatcher;
+} // Used to distinguish these contexts from ones used in other renderers.
+var ScriptStreamingFormat = 0;
+var DataStreamingFormat = 1;
+var NothingSent
+/* */
+= 0;
+var SentCompleteSegmentFunction
+/* */
+= 1;
+var SentCompleteBoundaryFunction
+/* */
+= 2;
+var SentClientRenderFunction
+/* */
+= 4;
+var SentStyleInsertionFunction
+/* */
+= 8; // Per response, global state that is not contextual to the rendering subtree.
+
+var dataElementQuotedEnd = stringToPrecomputedChunk('">');
+var startInlineScript = stringToPrecomputedChunk('');
+var startScriptSrc = stringToPrecomputedChunk('');
+/**
+ * This escaping function is designed to work with bootstrapScriptContent only.
+ * because we know we are escaping the entire script. We can avoid for instance
+ * escaping html comment string sequences that are valid javascript as well because
+ * if there are no sebsequent ');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderDataEnd);
+ }
+}
+var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
+
+function escapeJSStringsForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInInstructionScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ 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');
+ }
+ }
+ });
+}
+
+var regexForJSStringsInScripts = /[&><\u2028\u2029]/g;
+
+function escapeJSObjectForInstructionScripts(input) {
+ var escaped = JSON.stringify(input);
+ return escaped.replace(regexForJSStringsInScripts, function (match) {
+ switch (match) {
+ // santizing breaking out of strings and script tags
+ case '&':
+ return "\\u0026";
+
+ case '>':
+ return "\\u003e";
+
+ case '<':
+ return "\\u003c";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ default:
+ {
+ // eslint-disable-next-line react-internal/prod-error-codes
+ throw new Error('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');
+ }
+ }
+ });
+}
+
+var lateStyleTagResourceOpen1 = stringToPrecomputedChunk(''); // Tracks whether the boundary currently flushing is flushign style tags or has any
+// stylesheet dependencies not flushed in the Preamble.
+
+var currentlyRenderingBoundaryHasStylesToHoist = false; // Acts as a return value for the forEach execution of style tag flushing.
+
+var destinationHasCapacity = true;
+
+function flushStyleTagsLateForBoundary(resource) {
+ if (resource.type === 'stylesheet' && (resource.state & FlushedInPreamble) === NoState) {
+ currentlyRenderingBoundaryHasStylesToHoist = true;
+ } else if (resource.type === 'style') {
+ var chunks = resource.chunks;
+ var hrefs = resource.props.hrefs;
+ var i = 0;
+
+ if (chunks.length) {
+ writeChunk(this, lateStyleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(resource.props.precedence)));
+
+ if (hrefs.length) {
+ writeChunk(this, lateStyleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, lateStyleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ destinationHasCapacity = writeChunkAndReturn(this, lateStyleTagTemplateClose); // We wrote style tags for this boundary and we may need to emit a script
+ // to hoist them.
+
+ currentlyRenderingBoundaryHasStylesToHoist = true; // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+ }
+}
+
+function writeResourcesForBoundary(destination, boundaryResources, responseState) {
+ // Reset these on each invocation, they are only safe to read in this function
+ currentlyRenderingBoundaryHasStylesToHoist = false;
+ destinationHasCapacity = true; // Flush each Boundary resource
+
+ boundaryResources.forEach(flushStyleTagsLateForBoundary, destination);
+
+ if (currentlyRenderingBoundaryHasStylesToHoist) {
+ responseState.stylesToHoist = true;
+ }
+
+ return destinationHasCapacity;
+}
+
+function flushResourceInPreamble(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedInPreamble;
+ }
+}
+
+function flushResourceLate(resource) {
+ if ((resource.state & (Flushed | Blocked)) === NoState) {
+ var chunks = resource.chunks;
+
+ for (var i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ resource.state |= FlushedLate;
+ }
+} // This must always be read after flushing stylesheet styles. we know we will encounter a style resource
+// per precedence and it will be set before ready so we cast this to avoid an extra check at runtime
+
+
+var precedenceStyleTagResource = null; // This flags let's us opt out of flushing a placeholder style tag to emit the precedence in the right order.
+// If a stylesheet was flushed then we have the precedence order preserved and only need to emit ');
+
+function flushAllStylesInPreamble(set, precedence) {
+ didFlushPrecedence = false;
+ set.forEach(flushStyleInPreamble, this);
+ set.clear();
+ var chunks = precedenceStyleTagResource.chunks;
+ var hrefs = precedenceStyleTagResource.props.hrefs;
+
+ if (didFlushPrecedence === false || chunks.length) {
+ writeChunk(this, styleTagResourceOpen1);
+ writeChunk(this, stringToChunk(escapeTextForBrowser(precedence)));
+ var i = 0;
+
+ if (hrefs.length) {
+ writeChunk(this, styleTagResourceOpen2);
+
+ for (; i < hrefs.length - 1; i++) {
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ writeChunk(this, spaceSeparator);
+ }
+
+ writeChunk(this, stringToChunk(escapeTextForBrowser(hrefs[i])));
+ }
+
+ writeChunk(this, styleTagResourceOpen3);
+
+ for (i = 0; i < chunks.length; i++) {
+ writeChunk(this, chunks[i]);
+ }
+
+ writeChunk(this, styleTagResourceClose); // style resources can flush continuously since more rules may be written into
+ // them with new hrefs. Instead of marking it flushed, we simply reset the chunks
+ // and hrefs
+
+ chunks.length = 0;
+ hrefs.length = 0;
+ }
+}
+
+function preloadLateStyle(resource) {
+ {
+ if (resource.state & PreloadFlushed) {
+ error('React encountered a Stylesheet Resource that already flushed a Preload when it was not expected to. This is a bug in React.');
+ }
+ }
+
+ if (resource.type === 'style') {
+ // "),Ec=!1,Fc=!0;function Gc(a){if("stylesheet"===a.type&&0===(a.state&1))Ec=!0;else if("style"===a.type){var b=a.chunks,c=a.props.hrefs,d=0;if(b.length){p(this,Ac);p(this,B(a.props.precedence));if(c.length){for(p(this,Bc);d'),Pc=y("");function Qc(a,b){Kc=!1;a.forEach(Lc,this);a.clear();a=Jc.chunks;var c=Jc.props.hrefs;if(!1===Kc||a.length){p(this,Mc);p(this,B(b));b=0;if(c.length){for(p(this,Nc);ba.depth?Ed(b,a):Fd(b,a),V=a)}
+var Hd={isMounted:function(){return!1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b)},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b]},enqueueForceUpdate:function(){}};
+function Id(a,b,c,d){var e=void 0!==a.state?a.state:null;a.updater=Hd;a.props=c;a.state=e;var f={queue:[],replace:!1};a._reactInternals=f;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,e),e=null===g||void 0===g?e:z({},e,g),a.state=e);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
+a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Hd.enqueueReplaceState(a,a.state,null),null!==f.queue&&0>=g;e-=g;return{id:1<<32-Ld(b)+e|c<>>=0;return 0===a?32:31-(Nd(a)/Od|0)|0}var Pd=Error("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`");
+function Qd(){}function Rd(a,b,c){c=a[c];void 0===c?a.push(b):c!==b&&(b.then(Qd,Qd),b=c);switch(b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;default:if("string"!==typeof b.status)switch(a=b,a.status="pending",a.then(function(d){if("pending"===b.status){var e=b;e.status="fulfilled";e.value=d}},function(d){if("pending"===b.status){var e=b;e.status="rejected";e.reason=d}}),b.status){case "fulfilled":return b.value;case "rejected":throw b.reason;}Sd=b;throw Pd;}}var Sd=null;
+function Td(){if(null===Sd)throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");var a=Sd;Sd=null;return a}function Ud(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Vd="function"===typeof Object.is?Object.is:Ud,W=null,Wd=null,Xd=null,X=null,Yd=!1,Zd=!1,$d=0,ae=0,be=null,Y=null,ce=0;
+function de(){if(null===W)throw 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:\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://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");return W}
+function ee(){if(0=
+f.insertionMode){a.responseState.hasBody=!0;break a}break;case "html":if(0===f.insertionMode)break a}b.push(R,d,S)}c.lastPushedText=!1}else{switch(d){case sd:case qd:case fd:case gd:case ed:Z(a,b,null,e.children);return;case rd:"hidden"!==e.mode&&Z(a,b,null,e.children);return;case md:Z(a,b,null,e.children);return;case pd:throw Error("ReactDOMServer does not yet support scope components.");case ld:a:{d=b.blockedBoundary;c=b.blockedSegment;f=e.fallback;e=e.children;g=new Set;var k={id:null,rootSegmentID:-1,
+parentFlushed:!1,pendingTasks:0,forceClientRender:!1,completedSegments:[],byteSize:0,fallbackAbortableTasks:g,errorDigest:null,resources:new Set},m=Ae(a,c.chunks.length,k,c.formatContext,!1,!1);c.children.push(m);c.lastPushedText=!1;var n=Ae(a,0,null,c.formatContext,!1,!1);n.parentFlushed=!0;b.blockedBoundary=k;b.blockedSegment=n;a.resources.boundaryResources=k.resources;try{if(Je(a,b,e),n.lastPushedText&&n.textEmbedded&&n.chunks.push(G),n.status=1,Ke(k,n),0===k.pendingTasks)break a}catch(r){n.status=
+4,k.forceClientRender=!0,k.errorDigest=Ee(a,r)}finally{a.resources.boundaryResources=d?d.resources:null,b.blockedBoundary=d,b.blockedSegment=c}b=Be(a,null,f,d,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b)}return}if("object"===typeof d&&null!==d)switch(d.$$typeof){case kd:d=d.render;W={};Wd=b;ae=$d=0;be=c;c=d(e,f);e=ge(d,e,c,f);if(0!==$d){d=b.treeContext;b.treeContext=Kd(d,1,0);try{Z(a,b,null,e)}finally{b.treeContext=d}}else Z(a,b,null,e);return;case nd:d=d.type;e=He(d,e);Ie(a,
+b,c,d,e,f);return;case hd:c=e.children;d=d._context;e=e.value;f=d._currentValue;d._currentValue=e;g=V;V=e={parent:g,depth:null===g?0:g.depth+1,context:d,parentValue:f,value:e};b.context=e;Z(a,b,null,c);a=V;if(null===a)throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");e=a.parentValue;a.context._currentValue=e===ud?a.context._defaultValue:e;a=V=a.parent;b.context=a;return;case id:e=e.children;e=e(d._currentValue);Z(a,b,null,e);return;case od:f=d._init;d=f(d._payload);
+e=He(d,e);Ie(a,b,c,d,e,void 0);return}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+((null==d?d:typeof d)+"."));}}
+function Z(a,b,c,d){b.node=d;if("object"===typeof d&&null!==d){switch(d.$$typeof){case cd:Ie(a,b,c,d.type,d.props,d.ref);return;case dd:throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");case od:c=d._init;d=c(d._payload);Z(a,b,null,d);return}if(va(d)){Le(a,b,d);return}null===d||"object"!==typeof d?c=null:(c=wd&&d[wd]||d["@@iterator"],c="function"===typeof c?c:null);if(c&&(c=c.call(d))){d=c.next();if(!d.done){var e=
+[];do e.push(d.value),d=c.next();while(!d.done);Le(a,b,e)}return}if("function"===typeof d.then)return Z(a,b,null,pe(d));if(d.$$typeof===id||d.$$typeof===jd)return Z(a,b,null,d._currentValue);a=Object.prototype.toString.call(d);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===a?"object with keys {"+Object.keys(d).join(", ")+"}":a)+"). If you meant to render a collection of children, use an array instead.");}"string"===typeof d?(c=b.blockedSegment,c.lastPushedText=
+Pa(b.blockedSegment.chunks,d,a.responseState,c.lastPushedText)):"number"===typeof d&&(c=b.blockedSegment,c.lastPushedText=Pa(b.blockedSegment.chunks,""+d,a.responseState,c.lastPushedText))}function Le(a,b,c){for(var d=c.length,e=0;ea.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),
+xb(b,a.responseState,d.id),Qe(a,b,c);else{(c=a.resources.boundaryResources)&&d.resources.forEach(bd,c);x(b,ob);c=d.completedSegments;if(1!==c.length)throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");Re(a,b,c[0])}return x(b,sb)}function Se(a,b,c){Tb(b,a.responseState,c.formatContext,c.id);Re(a,b,c);return Ub(b,c.formatContext)}
+function Te(a,b,c){a.resources.boundaryResources=c.resources;for(var d=c.completedSegments,e=0;e 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ printWarning('warn', format, args);
+ }
+ }
+}
+function error(format) {
+ {
+ if (!suppressWarning) {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ printWarning('error', format, args);
+ }
+ }
+}
+
+function printWarning(level, format, args) {
+ // When changing this logic, you might want to also
+ // update consoleWithStackDev.www.js as well.
+ {
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ if (stack !== '') {
+ format += '%s';
+ args = args.concat([stack]);
+ } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+ var argsWithFormat = args.map(function (item) {
+ return String(item);
+ }); // Careful: RN currently depends on this prefix
+
+ argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+ // breaks IE9: https://github.com/facebook/react/issues/13610
+ // eslint-disable-next-line react-internal/no-production-logging
+
+ Function.prototype.apply.call(console[level], console, argsWithFormat);
+ }
+}
+
+var assign = Object.assign;
+
+var valueStack = [];
+var fiberStack;
+
+{
+ fiberStack = [];
+}
+
+var index = -1;
+
+function createCursor(defaultValue) {
+ return {
+ current: defaultValue
+ };
+}
+
+function pop(cursor, fiber) {
+ if (index < 0) {
+ {
+ error('Unexpected pop.');
+ }
+
+ return;
+ }
+
+ {
+ if (fiber !== fiberStack[index]) {
+ error('Unexpected Fiber popped.');
+ }
+ }
+
+ cursor.current = valueStack[index];
+ valueStack[index] = null;
+
+ {
+ fiberStack[index] = null;
+ }
+
+ index--;
+}
+
+function push(cursor, value, fiber) {
+ index++;
+ valueStack[index] = cursor.current;
+
+ {
+ fiberStack[index] = fiber;
+ }
+
+ cursor.current = value;
+}
+
+var contextStackCursor$1 = createCursor(null);
+var contextFiberStackCursor = createCursor(null);
+var rootInstanceStackCursor = createCursor(null);
+
+function requiredContext(c) {
+ {
+ if (c === null) {
+ error('Expected host context to exist. This error is likely caused by a bug ' + 'in React. Please file an issue.');
+ }
+ }
+
+ return c;
+}
+
+function getCurrentRootHostContainer() {
+ return rootInstanceStackCursor.current;
+}
+
+function getRootHostContainer() {
+ var rootInstance = requiredContext(rootInstanceStackCursor.current);
+ return rootInstance;
+}
+
+function pushHostContainer(fiber, nextRootInstance) {
+ // Push current root instance onto the stack;
+ // This allows us to reset root when portals are popped.
+ push(rootInstanceStackCursor, nextRootInstance, fiber); // Track the context and the Fiber that provided it.
+ // This enables us to pop only Fibers that provide unique contexts.
+
+ push(contextFiberStackCursor, fiber, fiber); // Finally, we need to push the host context to the stack.
+ // However, we can't just call getRootHostContext() and push it because
+ // we'd have a different number of entries on the stack depending on
+ // whether getRootHostContext() throws somewhere in renderer code or not.
+ // So we push an empty value first. This lets us safely unwind on errors.
+
+ push(contextStackCursor$1, null, fiber);
+ var nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+
+ pop(contextStackCursor$1, fiber);
+ push(contextStackCursor$1, nextRootContext, fiber);
+}
+
+function popHostContainer(fiber) {
+ pop(contextStackCursor$1, fiber);
+ pop(contextFiberStackCursor, fiber);
+ pop(rootInstanceStackCursor, fiber);
+}
+
+function getHostContext() {
+ var context = requiredContext(contextStackCursor$1.current);
+ return context;
+}
+
+function pushHostContext(fiber) {
+ var context = requiredContext(contextStackCursor$1.current);
+ var nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+
+ if (context === nextContext) {
+ return;
+ } // Track the context and the Fiber that provided it.
+ // This enables us to pop only Fibers that provide unique contexts.
+
+
+ push(contextFiberStackCursor, fiber, fiber);
+ push(contextStackCursor$1, nextContext, fiber);
+}
+
+function popHostContext(fiber) {
+ // Do not pop unless this Fiber provided the current context.
+ // pushHostContext() only pushes Fibers that provide unique contexts.
+ if (contextFiberStackCursor.current !== fiber) {
+ return;
+ }
+
+ pop(contextStackCursor$1, fiber);
+ pop(contextFiberStackCursor, fiber);
+}
+
+// -----------------------------------------------------------------------------
+// Killswitch
+//
+// Flags that exist solely to turn off a change in case it causes a regression
+// when it rolls out to prod. We should remove these as soon as possible.
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Land or remove (moderate effort)
+//
+// Flags that can be probably deleted or landed, but might require extra effort
+// like migrating internal callers or performance testing.
+// -----------------------------------------------------------------------------
+// TODO: Finish rolling out in www
+
+var enableClientRenderFallbackOnTextMismatch = true; // Recoil still uses useMutableSource in www, need to delete
+// Slated for removal in the future (significant effort)
+//
+// These are experiments that didn't work out, and never shipped, but we can't
+// delete from the codebase until we migrate internal callers.
+// -----------------------------------------------------------------------------
+// Add a callback property to suspense to notify which promises are currently
+// in the update queue. This allows reporting and tracing of what is causing
+// the user to see a loading state.
+//
+// Also allows hydration callbacks to fire when a dehydrated boundary gets
+// hydrated or deleted.
+//
+// This will eventually be replaced by the Transition Tracing proposal.
+
+var enableSuspenseCallback = false; // Experimental Scope support.
+var enableFormActions = true;
+
+var enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.
+
+var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+
+var diffInCommitPhase = true;
+var enableAsyncActions = true;
+var alwaysThrottleRetries = true; // -----------------------------------------------------------------------------
+// Chopping Block
+//
+// Planned feature deprecations and breaking changes. Sorted roughly in order of
+// when we plan to enable them.
+// -----------------------------------------------------------------------------
+// This flag enables Strict Effects by default. We're not turning this on until
+// after 18 because it requires migration work. Recommendation is to use
+// to gradually upgrade components.
+// If TRUE, trees rendered with createRoot will be StrictEffectsMode.
+// If FALSE, these trees will be StrictLegacyMode.
+
+var createRootStrictEffectsByDefault = false;
+// React DOM Chopping Block
+//
+// Similar to main Chopping Block but only flags related to React DOM. These are
+// grouped because we will likely batch all of them into a single major release.
+// -----------------------------------------------------------------------------
+// Disable support for comment nodes as React DOM containers. Already disabled
+// in open source, but www codebase still relies on it. Need to remove.
+
+var disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.
+
+var disableIEWorkarounds = true; // Filter certain DOM attributes (e.g. src, href) if their values are empty
+// Debugging and DevTools
+// -----------------------------------------------------------------------------
+// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+// for an experimental timeline tool.
+
+var enableSchedulingProfiler = true; // Helps identify side effects in render-phase lifecycle hooks and setState
+
+var enableProfilerTimer = true; // Record durations for commit and passive effects phases.
+
+var enableProfilerCommitHooks = true; // Phase param passed to onRender callback differentiates between an "update" and a "cascading-update".
+
+var enableProfilerNestedUpdatePhase = true; // Adds verbose console logging for e.g. state updates, suspense, and work loop
+
+var NoFlags$1 =
+/* */
+0;
+var PerformedWork =
+/* */
+1;
+var Placement =
+/* */
+2;
+var DidCapture =
+/* */
+128;
+var Hydrating =
+/* */
+4096; // You can change the rest (and add more).
+
+var Update =
+/* */
+4;
+/* Skipped value: 0b0000000000000000000000001000; */
+
+var ChildDeletion =
+/* */
+16;
+var ContentReset =
+/* */
+32;
+var Callback =
+/* */
+64;
+/* Used by DidCapture: 0b0000000000000000000010000000; */
+
+var ForceClientRender =
+/* */
+256;
+var Ref =
+/* */
+512;
+var Snapshot =
+/* */
+1024;
+var Passive$1 =
+/* */
+2048;
+/* Used by Hydrating: 0b0000000000000001000000000000; */
+
+var Visibility =
+/* */
+8192;
+var StoreConsistency =
+/* */
+16384; // It's OK to reuse these bits because these flags are mutually exclusive for
+// different fiber types. We should really be doing this for as many flags as
+// possible, because we're about to run out of bits.
+
+var ScheduleRetry = StoreConsistency;
+var ShouldSuspendCommit = Visibility;
+var LifecycleEffectMask = Passive$1 | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)
+
+var HostEffectMask =
+/* */
+32767; // These are not really side effects, but we still reuse this field.
+
+var Incomplete =
+/* */
+32768;
+var ShouldCapture =
+/* */
+65536;
+var ForceUpdateForLegacySuspense =
+/* */
+131072;
+var Forked =
+/* */
+1048576; // Static tags describe aspects of a fiber that are not specific to a render,
+// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).
+// This enables us to defer more work in the unmount case,
+// since we can defer traversing the tree during layout to look for Passive effects,
+// and instead rely on the static flag as a signal that there may be cleanup work.
+
+var RefStatic =
+/* */
+2097152;
+var LayoutStatic =
+/* */
+4194304;
+var PassiveStatic =
+/* */
+8388608;
+var MaySuspendCommit =
+/* */
+16777216; // Flag used to identify newly inserted fibers. It isn't reset after commit unlike `Placement`.
+
+var PlacementDEV =
+/* */
+33554432;
+var MountLayoutDev =
+/* */
+67108864;
+var MountPassiveDev =
+/* */
+134217728; // Groups of flags that are used in the commit phase to skip over trees that
+// don't contain effects, by checking subtreeFlags.
+
+var BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility
+// flag logic (see #20043)
+Update | Snapshot | (0);
+var MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;
+var LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask
+
+var PassiveMask = Passive$1 | Visibility | ChildDeletion; // Union of tags that don't get reset on clones.
+// This allows certain concepts to persist without recalculating them,
+// e.g. whether a subtree contains passive effects or portals.
+
+var StaticMask = LayoutStatic | PassiveStatic | RefStatic | MaySuspendCommit;
+
+// This module only exists as an ESM wrapper around the external CommonJS
+var scheduleCallback$3 = Scheduler.unstable_scheduleCallback;
+var cancelCallback$1 = Scheduler.unstable_cancelCallback;
+var shouldYield = Scheduler.unstable_shouldYield;
+var requestPaint = Scheduler.unstable_requestPaint;
+var now$1 = Scheduler.unstable_now;
+var getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+var ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+var UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+var NormalPriority$1 = Scheduler.unstable_NormalPriority;
+var LowPriority = Scheduler.unstable_LowPriority;
+var IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+// on scheduler/unstable_mock, which we'll need for internal testing
+
+var log$1 = Scheduler.log;
+var unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue;
+
+// Helpers to patch console.logs to avoid logging during side-effect free
+// replaying on render function. This currently only patches the object
+// lazily which won't cover if the log function was extracted eagerly.
+// We could also eagerly patch the method.
+var disabledDepth = 0;
+var prevLog;
+var prevInfo;
+var prevWarn;
+var prevError;
+var prevGroup;
+var prevGroupCollapsed;
+var prevGroupEnd;
+
+function disabledLog() {}
+
+disabledLog.__reactDisabledLog = true;
+function disableLogs() {
+ {
+ if (disabledDepth === 0) {
+ /* eslint-disable react-internal/no-production-logging */
+ prevLog = console.log;
+ prevInfo = console.info;
+ prevWarn = console.warn;
+ prevError = console.error;
+ prevGroup = console.group;
+ prevGroupCollapsed = console.groupCollapsed;
+ prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+ var props = {
+ configurable: true,
+ enumerable: true,
+ value: disabledLog,
+ writable: true
+ }; // $FlowFixMe[cannot-write] Flow thinks console is immutable.
+
+ Object.defineProperties(console, {
+ info: props,
+ log: props,
+ warn: props,
+ error: props,
+ group: props,
+ groupCollapsed: props,
+ groupEnd: props
+ });
+ /* eslint-enable react-internal/no-production-logging */
+ }
+
+ disabledDepth++;
+ }
+}
+function reenableLogs() {
+ {
+ disabledDepth--;
+
+ if (disabledDepth === 0) {
+ /* eslint-disable react-internal/no-production-logging */
+ var props = {
+ configurable: true,
+ enumerable: true,
+ writable: true
+ }; // $FlowFixMe[cannot-write] Flow thinks console is immutable.
+
+ Object.defineProperties(console, {
+ log: assign({}, props, {
+ value: prevLog
+ }),
+ info: assign({}, props, {
+ value: prevInfo
+ }),
+ warn: assign({}, props, {
+ value: prevWarn
+ }),
+ error: assign({}, props, {
+ value: prevError
+ }),
+ group: assign({}, props, {
+ value: prevGroup
+ }),
+ groupCollapsed: assign({}, props, {
+ value: prevGroupCollapsed
+ }),
+ groupEnd: assign({}, props, {
+ value: prevGroupEnd
+ })
+ });
+ /* eslint-enable react-internal/no-production-logging */
+ }
+
+ if (disabledDepth < 0) {
+ error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+ }
+ }
+}
+
+var rendererID = null;
+var injectedHook = null;
+var injectedProfilingHooks = null;
+var hasLoggedError = false;
+var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined';
+function injectInternals(internals) {
+ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+ // No DevTools
+ return false;
+ }
+
+ var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+ if (hook.isDisabled) {
+ // This isn't a real property on the hook, but it can be set to opt out
+ // of DevTools integration and associated warnings and logs.
+ // https://github.com/facebook/react/issues/3877
+ return true;
+ }
+
+ if (!hook.supportsFiber) {
+ {
+ error('The installed version of React DevTools is too old and will not work ' + 'with the current version of React. Please update React DevTools. ' + 'https://reactjs.org/link/react-devtools');
+ } // DevTools exists, even though it doesn't support Fiber.
+
+
+ return true;
+ }
+
+ try {
+ if (enableSchedulingProfiler) {
+ // Conditionally inject these hooks only if Timeline profiler is supported by this build.
+ // This gives DevTools a way to feature detect that isn't tied to version number
+ // (since profiling and timeline are controlled by different feature flags).
+ internals = assign({}, internals, {
+ getLaneLabelMap: getLaneLabelMap,
+ injectProfilingHooks: injectProfilingHooks
+ });
+ }
+
+ rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+
+ injectedHook = hook;
+ } catch (err) {
+ // Catch all errors because it is unsafe to throw during initialization.
+ {
+ error('React instrumentation encountered an error: %s.', err);
+ }
+ }
+
+ if (hook.checkDCE) {
+ // This is the real DevTools.
+ return true;
+ } else {
+ // This is likely a hook installed by Fast Refresh runtime.
+ return false;
+ }
+}
+function onScheduleRoot(root, children) {
+ {
+ if (injectedHook && typeof injectedHook.onScheduleFiberRoot === 'function') {
+ try {
+ injectedHook.onScheduleFiberRoot(rendererID, root, children);
+ } catch (err) {
+ if (!hasLoggedError) {
+ hasLoggedError = true;
+
+ error('React instrumentation encountered an error: %s', err);
+ }
+ }
+ }
+ }
+}
+function onCommitRoot$1(root, eventPriority) {
+ if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
+ try {
+ var didError = (root.current.flags & DidCapture) === DidCapture;
+
+ if (enableProfilerTimer) {
+ var schedulerPriority;
+
+ switch (eventPriority) {
+ case DiscreteEventPriority:
+ schedulerPriority = ImmediatePriority;
+ break;
+
+ case ContinuousEventPriority:
+ schedulerPriority = UserBlockingPriority;
+ break;
+
+ case DefaultEventPriority:
+ schedulerPriority = NormalPriority$1;
+ break;
+
+ case IdleEventPriority:
+ schedulerPriority = IdlePriority;
+ break;
+
+ default:
+ schedulerPriority = NormalPriority$1;
+ break;
+ }
+
+ injectedHook.onCommitFiberRoot(rendererID, root, schedulerPriority, didError);
+ }
+ } catch (err) {
+ {
+ if (!hasLoggedError) {
+ hasLoggedError = true;
+
+ error('React instrumentation encountered an error: %s', err);
+ }
+ }
+ }
+ }
+}
+function onPostCommitRoot(root) {
+ if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {
+ try {
+ injectedHook.onPostCommitFiberRoot(rendererID, root);
+ } catch (err) {
+ {
+ if (!hasLoggedError) {
+ hasLoggedError = true;
+
+ error('React instrumentation encountered an error: %s', err);
+ }
+ }
+ }
+ }
+}
+function onCommitUnmount(fiber) {
+ if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
+ try {
+ injectedHook.onCommitFiberUnmount(rendererID, fiber);
+ } catch (err) {
+ {
+ if (!hasLoggedError) {
+ hasLoggedError = true;
+
+ error('React instrumentation encountered an error: %s', err);
+ }
+ }
+ }
+ }
+}
+function setIsStrictModeForDevtools(newIsStrictMode) {
+ {
+ if (typeof log$1 === 'function') {
+ // We're in a test because Scheduler.log only exists
+ // in SchedulerMock. To reduce the noise in strict mode tests,
+ // suppress warnings and disable scheduler yielding during the double render
+ unstable_setDisableYieldValue(newIsStrictMode);
+ setSuppressWarning(newIsStrictMode);
+ }
+
+ if (injectedHook && typeof injectedHook.setStrictMode === 'function') {
+ try {
+ injectedHook.setStrictMode(rendererID, newIsStrictMode);
+ } catch (err) {
+ {
+ if (!hasLoggedError) {
+ hasLoggedError = true;
+
+ error('React instrumentation encountered an error: %s', err);
+ }
+ }
+ }
+ }
+ }
+} // Profiler API hooks
+
+function injectProfilingHooks(profilingHooks) {
+ injectedProfilingHooks = profilingHooks;
+}
+
+function getLaneLabelMap() {
+ {
+ var map = new Map();
+ var lane = 1;
+
+ for (var index = 0; index < TotalLanes; index++) {
+ var label = getLabelForLane(lane);
+ map.set(lane, label);
+ lane *= 2;
+ }
+
+ return map;
+ }
+}
+
+function markCommitStarted(lanes) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markCommitStarted === 'function') {
+ injectedProfilingHooks.markCommitStarted(lanes);
+ }
+ }
+}
+function markCommitStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markCommitStopped === 'function') {
+ injectedProfilingHooks.markCommitStopped();
+ }
+ }
+}
+function markComponentRenderStarted(fiber) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentRenderStarted === 'function') {
+ injectedProfilingHooks.markComponentRenderStarted(fiber);
+ }
+ }
+}
+function markComponentRenderStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentRenderStopped === 'function') {
+ injectedProfilingHooks.markComponentRenderStopped();
+ }
+ }
+}
+function markComponentPassiveEffectMountStarted(fiber) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted === 'function') {
+ injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+ }
+ }
+}
+function markComponentPassiveEffectMountStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped === 'function') {
+ injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+ }
+ }
+}
+function markComponentPassiveEffectUnmountStarted(fiber) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted === 'function') {
+ injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+ }
+ }
+}
+function markComponentPassiveEffectUnmountStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped === 'function') {
+ injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+ }
+ }
+}
+function markComponentLayoutEffectMountStarted(fiber) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted === 'function') {
+ injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+ }
+ }
+}
+function markComponentLayoutEffectMountStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped === 'function') {
+ injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+ }
+ }
+}
+function markComponentLayoutEffectUnmountStarted(fiber) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted === 'function') {
+ injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+ }
+ }
+}
+function markComponentLayoutEffectUnmountStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped === 'function') {
+ injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+ }
+ }
+}
+function markComponentErrored(fiber, thrownValue, lanes) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentErrored === 'function') {
+ injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+ }
+ }
+}
+function markComponentSuspended(fiber, wakeable, lanes) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markComponentSuspended === 'function') {
+ injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+ }
+ }
+}
+function markLayoutEffectsStarted(lanes) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markLayoutEffectsStarted === 'function') {
+ injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+ }
+ }
+}
+function markLayoutEffectsStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markLayoutEffectsStopped === 'function') {
+ injectedProfilingHooks.markLayoutEffectsStopped();
+ }
+ }
+}
+function markPassiveEffectsStarted(lanes) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markPassiveEffectsStarted === 'function') {
+ injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+ }
+ }
+}
+function markPassiveEffectsStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markPassiveEffectsStopped === 'function') {
+ injectedProfilingHooks.markPassiveEffectsStopped();
+ }
+ }
+}
+function markRenderStarted(lanes) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderStarted === 'function') {
+ injectedProfilingHooks.markRenderStarted(lanes);
+ }
+ }
+}
+function markRenderYielded() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderYielded === 'function') {
+ injectedProfilingHooks.markRenderYielded();
+ }
+ }
+}
+function markRenderStopped() {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderStopped === 'function') {
+ injectedProfilingHooks.markRenderStopped();
+ }
+ }
+}
+function markRenderScheduled(lane) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markRenderScheduled === 'function') {
+ injectedProfilingHooks.markRenderScheduled(lane);
+ }
+ }
+}
+function markForceUpdateScheduled(fiber, lane) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markForceUpdateScheduled === 'function') {
+ injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+ }
+ }
+}
+function markStateUpdateScheduled(fiber, lane) {
+ {
+ if (injectedProfilingHooks !== null && typeof injectedProfilingHooks.markStateUpdateScheduled === 'function') {
+ injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+ }
+ }
+}
+
+var NoMode =
+/* */
+0; // TODO: Remove ConcurrentMode by reading from the root tag instead
+
+var ConcurrentMode =
+/* */
+1;
+var ProfileMode =
+/* */
+2;
+var StrictLegacyMode =
+/* */
+8;
+var StrictEffectsMode =
+/* */
+16;
+
+// TODO: This is pretty well supported by browsers. Maybe we can drop it.
+var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback; // Count leading zeros.
+// Based on:
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
+
+var log = Math.log;
+var LN2 = Math.LN2;
+
+function clz32Fallback(x) {
+ var asUint = x >>> 0;
+
+ if (asUint === 0) {
+ return 32;
+ }
+
+ return 31 - (log(asUint) / LN2 | 0) | 0;
+}
+
+// If those values are changed that package should be rebuilt and redeployed.
+
+var TotalLanes = 31;
+var NoLanes =
+/* */
+0;
+var NoLane =
+/* */
+0;
+var SyncHydrationLane =
+/* */
+1;
+var SyncLane =
+/* */
+2;
+var InputContinuousHydrationLane =
+/* */
+4;
+var InputContinuousLane =
+/* */
+8;
+var DefaultHydrationLane =
+/* */
+16;
+var DefaultLane =
+/* */
+32;
+var SyncUpdateLanes =
+/* */
+42;
+var TransitionHydrationLane =
+/* */
+64;
+var TransitionLanes =
+/* */
+8388480;
+var TransitionLane1 =
+/* */
+128;
+var TransitionLane2 =
+/* */
+256;
+var TransitionLane3 =
+/* */
+512;
+var TransitionLane4 =
+/* */
+1024;
+var TransitionLane5 =
+/* */
+2048;
+var TransitionLane6 =
+/* */
+4096;
+var TransitionLane7 =
+/* */
+8192;
+var TransitionLane8 =
+/* */
+16384;
+var TransitionLane9 =
+/* */
+32768;
+var TransitionLane10 =
+/* */
+65536;
+var TransitionLane11 =
+/* */
+131072;
+var TransitionLane12 =
+/* */
+262144;
+var TransitionLane13 =
+/* */
+524288;
+var TransitionLane14 =
+/* */
+1048576;
+var TransitionLane15 =
+/* */
+2097152;
+var TransitionLane16 =
+/* */
+4194304;
+var RetryLanes =
+/* */
+125829120;
+var RetryLane1 =
+/* */
+8388608;
+var RetryLane2 =
+/* */
+16777216;
+var RetryLane3 =
+/* */
+33554432;
+var RetryLane4 =
+/* */
+67108864;
+var SomeRetryLane = RetryLane1;
+var SelectiveHydrationLane =
+/* */
+134217728;
+var NonIdleLanes =
+/* */
+268435455;
+var IdleHydrationLane =
+/* */
+268435456;
+var IdleLane =
+/* */
+536870912;
+var OffscreenLane =
+/* */
+1073741824; // This function is used for the experimental timeline (react-devtools-timeline)
+// It should be kept in sync with the Lanes values above.
+
+function getLabelForLane(lane) {
+ {
+ if (lane & SyncHydrationLane) {
+ return 'SyncHydrationLane';
+ }
+
+ if (lane & SyncLane) {
+ return 'Sync';
+ }
+
+ if (lane & InputContinuousHydrationLane) {
+ return 'InputContinuousHydration';
+ }
+
+ if (lane & InputContinuousLane) {
+ return 'InputContinuous';
+ }
+
+ if (lane & DefaultHydrationLane) {
+ return 'DefaultHydration';
+ }
+
+ if (lane & DefaultLane) {
+ return 'Default';
+ }
+
+ if (lane & TransitionHydrationLane) {
+ return 'TransitionHydration';
+ }
+
+ if (lane & TransitionLanes) {
+ return 'Transition';
+ }
+
+ if (lane & RetryLanes) {
+ return 'Retry';
+ }
+
+ if (lane & SelectiveHydrationLane) {
+ return 'SelectiveHydration';
+ }
+
+ if (lane & IdleHydrationLane) {
+ return 'IdleHydration';
+ }
+
+ if (lane & IdleLane) {
+ return 'Idle';
+ }
+
+ if (lane & OffscreenLane) {
+ return 'Offscreen';
+ }
+ }
+}
+var NoTimestamp = -1;
+var nextTransitionLane = TransitionLane1;
+var nextRetryLane = RetryLane1;
+
+function getHighestPriorityLanes(lanes) {
+ {
+ var pendingSyncLanes = lanes & SyncUpdateLanes;
+
+ if (pendingSyncLanes !== 0) {
+ return pendingSyncLanes;
+ }
+ }
+
+ switch (getHighestPriorityLane(lanes)) {
+ case SyncHydrationLane:
+ return SyncHydrationLane;
+
+ case SyncLane:
+ return SyncLane;
+
+ case InputContinuousHydrationLane:
+ return InputContinuousHydrationLane;
+
+ case InputContinuousLane:
+ return InputContinuousLane;
+
+ case DefaultHydrationLane:
+ return DefaultHydrationLane;
+
+ case DefaultLane:
+ return DefaultLane;
+
+ case TransitionHydrationLane:
+ return TransitionHydrationLane;
+
+ case TransitionLane1:
+ case TransitionLane2:
+ case TransitionLane3:
+ case TransitionLane4:
+ case TransitionLane5:
+ case TransitionLane6:
+ case TransitionLane7:
+ case TransitionLane8:
+ case TransitionLane9:
+ case TransitionLane10:
+ case TransitionLane11:
+ case TransitionLane12:
+ case TransitionLane13:
+ case TransitionLane14:
+ case TransitionLane15:
+ case TransitionLane16:
+ return lanes & TransitionLanes;
+
+ case RetryLane1:
+ case RetryLane2:
+ case RetryLane3:
+ case RetryLane4:
+ return lanes & RetryLanes;
+
+ case SelectiveHydrationLane:
+ return SelectiveHydrationLane;
+
+ case IdleHydrationLane:
+ return IdleHydrationLane;
+
+ case IdleLane:
+ return IdleLane;
+
+ case OffscreenLane:
+ return OffscreenLane;
+
+ default:
+ {
+ error('Should have found matching lanes. This is a bug in React.');
+ } // This shouldn't be reachable, but as a fallback, return the entire bitmask.
+
+
+ return lanes;
+ }
+}
+
+function getNextLanes(root, wipLanes) {
+ // Early bailout if there's no pending work left.
+ var pendingLanes = root.pendingLanes;
+
+ if (pendingLanes === NoLanes) {
+ return NoLanes;
+ }
+
+ var nextLanes = NoLanes;
+ var suspendedLanes = root.suspendedLanes;
+ var pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,
+ // even if the work is suspended.
+
+ var nonIdlePendingLanes = pendingLanes & NonIdleLanes;
+
+ if (nonIdlePendingLanes !== NoLanes) {
+ var nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
+
+ if (nonIdleUnblockedLanes !== NoLanes) {
+ nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
+ } else {
+ var nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
+
+ if (nonIdlePingedLanes !== NoLanes) {
+ nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
+ }
+ }
+ } else {
+ // The only remaining work is Idle.
+ var unblockedLanes = pendingLanes & ~suspendedLanes;
+
+ if (unblockedLanes !== NoLanes) {
+ nextLanes = getHighestPriorityLanes(unblockedLanes);
+ } else {
+ if (pingedLanes !== NoLanes) {
+ nextLanes = getHighestPriorityLanes(pingedLanes);
+ }
+ }
+ }
+
+ if (nextLanes === NoLanes) {
+ // This should only be reachable if we're suspended
+ // TODO: Consider warning in this path if a fallback timer is not scheduled.
+ return NoLanes;
+ } // If we're already in the middle of a render, switching lanes will interrupt
+ // it and we'll lose our progress. We should only do this if the new lanes are
+ // higher priority.
+
+
+ if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
+ // bother waiting until the root is complete.
+ (wipLanes & suspendedLanes) === NoLanes) {
+ var nextLane = getHighestPriorityLane(nextLanes);
+ var wipLane = getHighestPriorityLane(wipLanes);
+
+ if ( // Tests whether the next lane is equal or lower priority than the wip
+ // one. This works because the bits decrease in priority as you go left.
+ nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The
+ // only difference between default updates and transition updates is that
+ // default updates do not support refresh transitions.
+ nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {
+ // Keep working on the existing in-progress tree. Do not interrupt.
+ return wipLanes;
+ }
+ }
+
+ if ((nextLanes & InputContinuousLane) !== NoLanes) {
+ // When updates are sync by default, we entangle continuous priority updates
+ // and default updates, so they render in the same batch. The only reason
+ // they use separate lanes is because continuous updates should interrupt
+ // transitions, but default updates should not.
+ nextLanes |= pendingLanes & DefaultLane;
+ } // Check for entangled lanes and add them to the batch.
+ //
+ // A lane is said to be entangled with another when it's not allowed to render
+ // in a batch that does not also include the other lane. Typically we do this
+ // when multiple updates have the same source, and we only want to respond to
+ // the most recent event from that source.
+ //
+ // Note that we apply entanglements *after* checking for partial work above.
+ // This means that if a lane is entangled during an interleaved event while
+ // it's already rendering, we won't interrupt it. This is intentional, since
+ // entanglement is usually "best effort": we'll try our best to render the
+ // lanes in the same batch, but it's not worth throwing out partially
+ // completed work in order to do it.
+ // TODO: Reconsider this. The counter-argument is that the partial work
+ // represents an intermediate state, which we don't want to show to the user.
+ // And by spending extra time finishing it, we're increasing the amount of
+ // time it takes to show the final state, which is what they are actually
+ // waiting for.
+ //
+ // For those exceptions where entanglement is semantically important, like
+ // useMutableSource, we should ensure that there is no partial work at the
+ // time we apply the entanglement.
+
+
+ var entangledLanes = root.entangledLanes;
+
+ if (entangledLanes !== NoLanes) {
+ var entanglements = root.entanglements;
+ var lanes = nextLanes & entangledLanes;
+
+ while (lanes > 0) {
+ var index = pickArbitraryLaneIndex(lanes);
+ var lane = 1 << index;
+ nextLanes |= entanglements[index];
+ lanes &= ~lane;
+ }
+ }
+
+ return nextLanes;
+}
+
+function computeExpirationTime(lane, currentTime) {
+ switch (lane) {
+ case SyncHydrationLane:
+ case SyncLane:
+ case InputContinuousHydrationLane:
+ case InputContinuousLane:
+ // User interactions should expire slightly more quickly.
+ //
+ // NOTE: This is set to the corresponding constant as in Scheduler.js.
+ // When we made it larger, a product metric in www regressed, suggesting
+ // there's a user interaction that's being starved by a series of
+ // synchronous updates. If that theory is correct, the proper solution is
+ // to fix the starvation. However, this scenario supports the idea that
+ // expiration times are an important safeguard when starvation
+ // does happen.
+ return currentTime + 250;
+
+ case DefaultHydrationLane:
+ case DefaultLane:
+ case TransitionHydrationLane:
+ case TransitionLane1:
+ case TransitionLane2:
+ case TransitionLane3:
+ case TransitionLane4:
+ case TransitionLane5:
+ case TransitionLane6:
+ case TransitionLane7:
+ case TransitionLane8:
+ case TransitionLane9:
+ case TransitionLane10:
+ case TransitionLane11:
+ case TransitionLane12:
+ case TransitionLane13:
+ case TransitionLane14:
+ case TransitionLane15:
+ case TransitionLane16:
+ return currentTime + 5000;
+
+ case RetryLane1:
+ case RetryLane2:
+ case RetryLane3:
+ case RetryLane4:
+ // TODO: Retries should be allowed to expire if they are CPU bound for
+ // too long, but when I made this change it caused a spike in browser
+ // crashes. There must be some other underlying bug; not super urgent but
+ // ideally should figure out why and fix it. Unfortunately we don't have
+ // a repro for the crashes, only detected via production metrics.
+ return NoTimestamp;
+
+ case SelectiveHydrationLane:
+ case IdleHydrationLane:
+ case IdleLane:
+ case OffscreenLane:
+ // Anything idle priority or lower should never expire.
+ return NoTimestamp;
+
+ default:
+ {
+ error('Should have found matching lanes. This is a bug in React.');
+ }
+
+ return NoTimestamp;
+ }
+}
+
+function markStarvedLanesAsExpired(root, currentTime) {
+ // TODO: This gets called every time we yield. We can optimize by storing
+ // the earliest expiration time on the root. Then use that to quickly bail out
+ // of this function.
+ var pendingLanes = root.pendingLanes;
+ var suspendedLanes = root.suspendedLanes;
+ var pingedLanes = root.pingedLanes;
+ var expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
+ // expiration time. If so, we'll assume the update is being starved and mark
+ // it as expired to force it to finish.
+ //
+ // We exclude retry lanes because those must always be time sliced, in order
+ // to unwrap uncached promises.
+ // TODO: Write a test for this
+
+ var lanes = pendingLanes & ~RetryLanes;
+
+ while (lanes > 0) {
+ var index = pickArbitraryLaneIndex(lanes);
+ var lane = 1 << index;
+ var expirationTime = expirationTimes[index];
+
+ if (expirationTime === NoTimestamp) {
+ // Found a pending lane with no expiration time. If it's not suspended, or
+ // if it's pinged, assume it's CPU-bound. Compute a new expiration time
+ // using the current time.
+ if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {
+ // Assumes timestamps are monotonically increasing.
+ expirationTimes[index] = computeExpirationTime(lane, currentTime);
+ }
+ } else if (expirationTime <= currentTime) {
+ // This lane expired
+ root.expiredLanes |= lane;
+ }
+
+ lanes &= ~lane;
+ }
+} // This returns the highest priority pending lanes regardless of whether they
+// are suspended.
+
+function getHighestPriorityPendingLanes(root) {
+ return getHighestPriorityLanes(root.pendingLanes);
+}
+function getLanesToRetrySynchronouslyOnError(root, originallyAttemptedLanes) {
+ if (root.errorRecoveryDisabledLanes & originallyAttemptedLanes) {
+ // The error recovery mechanism is disabled until these lanes are cleared.
+ return NoLanes;
+ }
+
+ var everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
+
+ if (everythingButOffscreen !== NoLanes) {
+ return everythingButOffscreen;
+ }
+
+ if (everythingButOffscreen & OffscreenLane) {
+ return OffscreenLane;
+ }
+
+ return NoLanes;
+}
+function includesSyncLane(lanes) {
+ return (lanes & (SyncLane | SyncHydrationLane)) !== NoLanes;
+}
+function includesNonIdleWork(lanes) {
+ return (lanes & NonIdleLanes) !== NoLanes;
+}
+function includesOnlyRetries(lanes) {
+ return (lanes & RetryLanes) === lanes;
+}
+function includesOnlyNonUrgentLanes(lanes) {
+ // TODO: Should hydration lanes be included here? This function is only
+ // used in `updateDeferredValueImpl`.
+ var UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;
+ return (lanes & UrgentLanes) === NoLanes;
+}
+function includesOnlyTransitions(lanes) {
+ return (lanes & TransitionLanes) === lanes;
+}
+function includesBlockingLane(root, lanes) {
+
+ var SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;
+ return (lanes & SyncDefaultLanes) !== NoLanes;
+}
+function includesExpiredLane(root, lanes) {
+ // This is a separate check from includesBlockingLane because a lane can
+ // expire after a render has already started.
+ return (lanes & root.expiredLanes) !== NoLanes;
+}
+function isTransitionLane(lane) {
+ return (lane & TransitionLanes) !== NoLanes;
+}
+function claimNextTransitionLane() {
+ // Cycle through the lanes, assigning each new transition to the next lane.
+ // In most cases, this means every transition gets its own lane, until we
+ // run out of lanes and cycle back to the beginning.
+ var lane = nextTransitionLane;
+ nextTransitionLane <<= 1;
+
+ if ((nextTransitionLane & TransitionLanes) === NoLanes) {
+ nextTransitionLane = TransitionLane1;
+ }
+
+ return lane;
+}
+function claimNextRetryLane() {
+ var lane = nextRetryLane;
+ nextRetryLane <<= 1;
+
+ if ((nextRetryLane & RetryLanes) === NoLanes) {
+ nextRetryLane = RetryLane1;
+ }
+
+ return lane;
+}
+function getHighestPriorityLane(lanes) {
+ return lanes & -lanes;
+}
+function pickArbitraryLane(lanes) {
+ // This wrapper function gets inlined. Only exists so to communicate that it
+ // doesn't matter which bit is selected; you can pick any bit without
+ // affecting the algorithms where its used. Here I'm using
+ // getHighestPriorityLane because it requires the fewest operations.
+ return getHighestPriorityLane(lanes);
+}
+
+function pickArbitraryLaneIndex(lanes) {
+ return 31 - clz32(lanes);
+}
+
+function laneToIndex(lane) {
+ return pickArbitraryLaneIndex(lane);
+}
+
+function includesSomeLane(a, b) {
+ return (a & b) !== NoLanes;
+}
+function isSubsetOfLanes(set, subset) {
+ return (set & subset) === subset;
+}
+function mergeLanes(a, b) {
+ return a | b;
+}
+function removeLanes(set, subset) {
+ return set & ~subset;
+}
+function intersectLanes(a, b) {
+ return a & b;
+} // Seems redundant, but it changes the type from a single lane (used for
+// updates) to a group of lanes (used for flushing work).
+
+function laneToLanes(lane) {
+ return lane;
+}
+function higherPriorityLane(a, b) {
+ // This works because the bit ranges decrease in priority as you go left.
+ return a !== NoLane && a < b ? a : b;
+}
+function createLaneMap(initial) {
+ // Intentionally pushing one by one.
+ // https://v8.dev/blog/elements-kinds#avoid-creating-holes
+ var laneMap = [];
+
+ for (var i = 0; i < TotalLanes; i++) {
+ laneMap.push(initial);
+ }
+
+ return laneMap;
+}
+function markRootUpdated(root, updateLane) {
+ root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update
+ // could unblock them. Clear the suspended lanes so that we can try rendering
+ // them again.
+ //
+ // TODO: We really only need to unsuspend only lanes that are in the
+ // `subtreeLanes` of the updated fiber, or the update lanes of the return
+ // path. This would exclude suspended updates in an unrelated sibling tree,
+ // since there's no way for this update to unblock it.
+ //
+ // We don't do this if the incoming update is idle, because we never process
+ // idle updates until after all the regular updates have finished; there's no
+ // way it could unblock a transition.
+
+ if (updateLane !== IdleLane) {
+ root.suspendedLanes = NoLanes;
+ root.pingedLanes = NoLanes;
+ }
+}
+function markRootSuspended$1(root, suspendedLanes) {
+ root.suspendedLanes |= suspendedLanes;
+ root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
+
+ var expirationTimes = root.expirationTimes;
+ var lanes = suspendedLanes;
+
+ while (lanes > 0) {
+ var index = pickArbitraryLaneIndex(lanes);
+ var lane = 1 << index;
+ expirationTimes[index] = NoTimestamp;
+ lanes &= ~lane;
+ }
+}
+function markRootPinged(root, pingedLanes) {
+ root.pingedLanes |= root.suspendedLanes & pingedLanes;
+}
+function markRootFinished(root, remainingLanes) {
+ var noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
+ root.pendingLanes = remainingLanes; // Let's try everything again
+
+ root.suspendedLanes = NoLanes;
+ root.pingedLanes = NoLanes;
+ root.expiredLanes &= remainingLanes;
+ root.mutableReadLanes &= remainingLanes;
+ root.entangledLanes &= remainingLanes;
+ root.errorRecoveryDisabledLanes &= remainingLanes;
+ var entanglements = root.entanglements;
+ var expirationTimes = root.expirationTimes;
+ var hiddenUpdates = root.hiddenUpdates; // Clear the lanes that no longer have pending work
+
+ var lanes = noLongerPendingLanes;
+
+ while (lanes > 0) {
+ var index = pickArbitraryLaneIndex(lanes);
+ var lane = 1 << index;
+ entanglements[index] = NoLanes;
+ expirationTimes[index] = NoTimestamp;
+ var hiddenUpdatesForLane = hiddenUpdates[index];
+
+ if (hiddenUpdatesForLane !== null) {
+ hiddenUpdates[index] = null; // "Hidden" updates are updates that were made to a hidden component. They
+ // have special logic associated with them because they may be entangled
+ // with updates that occur outside that tree. But once the outer tree
+ // commits, they behave like regular updates.
+
+ for (var i = 0; i < hiddenUpdatesForLane.length; i++) {
+ var update = hiddenUpdatesForLane[i];
+
+ if (update !== null) {
+ update.lane &= ~OffscreenLane;
+ }
+ }
+ }
+
+ lanes &= ~lane;
+ }
+}
+function markRootEntangled(root, entangledLanes) {
+ // In addition to entangling each of the given lanes with each other, we also
+ // have to consider _transitive_ entanglements. For each lane that is already
+ // entangled with *any* of the given lanes, that lane is now transitively
+ // entangled with *all* the given lanes.
+ //
+ // Translated: If C is entangled with A, then entangling A with B also
+ // entangles C with B.
+ //
+ // If this is hard to grasp, it might help to intentionally break this
+ // function and look at the tests that fail in ReactTransition-test.js. Try
+ // commenting out one of the conditions below.
+ var rootEntangledLanes = root.entangledLanes |= entangledLanes;
+ var entanglements = root.entanglements;
+ var lanes = rootEntangledLanes;
+
+ while (lanes) {
+ var index = pickArbitraryLaneIndex(lanes);
+ var lane = 1 << index;
+
+ if ( // Is this one of the newly entangled lanes?
+ lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?
+ entanglements[index] & entangledLanes) {
+ entanglements[index] |= entangledLanes;
+ }
+
+ lanes &= ~lane;
+ }
+}
+function markHiddenUpdate(root, update, lane) {
+ var index = laneToIndex(lane);
+ var hiddenUpdates = root.hiddenUpdates;
+ var hiddenUpdatesForLane = hiddenUpdates[index];
+
+ if (hiddenUpdatesForLane === null) {
+ hiddenUpdates[index] = [update];
+ } else {
+ hiddenUpdatesForLane.push(update);
+ }
+
+ update.lane = lane | OffscreenLane;
+}
+function getBumpedLaneForHydration(root, renderLanes) {
+ var renderLane = getHighestPriorityLane(renderLanes);
+ var lane;
+
+ if ((renderLane & SyncUpdateLanes) !== NoLane) {
+ lane = SyncHydrationLane;
+ } else {
+ switch (renderLane) {
+ case SyncLane:
+ lane = SyncHydrationLane;
+ break;
+
+ case InputContinuousLane:
+ lane = InputContinuousHydrationLane;
+ break;
+
+ case DefaultLane:
+ lane = DefaultHydrationLane;
+ break;
+
+ case TransitionLane1:
+ case TransitionLane2:
+ case TransitionLane3:
+ case TransitionLane4:
+ case TransitionLane5:
+ case TransitionLane6:
+ case TransitionLane7:
+ case TransitionLane8:
+ case TransitionLane9:
+ case TransitionLane10:
+ case TransitionLane11:
+ case TransitionLane12:
+ case TransitionLane13:
+ case TransitionLane14:
+ case TransitionLane15:
+ case TransitionLane16:
+ case RetryLane1:
+ case RetryLane2:
+ case RetryLane3:
+ case RetryLane4:
+ lane = TransitionHydrationLane;
+ break;
+
+ case IdleLane:
+ lane = IdleHydrationLane;
+ break;
+
+ default:
+ // Everything else is already either a hydration lane, or shouldn't
+ // be retried at a hydration lane.
+ lane = NoLane;
+ break;
+ }
+ } // Check if the lane we chose is suspended. If so, that indicates that we
+ // already attempted and failed to hydrate at that level. Also check if we're
+ // already rendering that lane, which is rare but could happen.
+
+
+ if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {
+ // Give up trying to hydrate and fall back to client render.
+ return NoLane;
+ }
+
+ return lane;
+}
+function addFiberToLanesMap(root, fiber, lanes) {
+
+ if (!isDevToolsPresent) {
+ return;
+ }
+
+ var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+
+ while (lanes > 0) {
+ var index = laneToIndex(lanes);
+ var lane = 1 << index;
+ var updaters = pendingUpdatersLaneMap[index];
+ updaters.add(fiber);
+ lanes &= ~lane;
+ }
+}
+function movePendingFibersToMemoized(root, lanes) {
+
+ if (!isDevToolsPresent) {
+ return;
+ }
+
+ var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+ var memoizedUpdaters = root.memoizedUpdaters;
+
+ while (lanes > 0) {
+ var index = laneToIndex(lanes);
+ var lane = 1 << index;
+ var updaters = pendingUpdatersLaneMap[index];
+
+ if (updaters.size > 0) {
+ updaters.forEach(function (fiber) {
+ var alternate = fiber.alternate;
+
+ if (alternate === null || !memoizedUpdaters.has(alternate)) {
+ memoizedUpdaters.add(fiber);
+ }
+ });
+ updaters.clear();
+ }
+
+ lanes &= ~lane;
+ }
+}
+function getTransitionsForLanes(root, lanes) {
+ {
+ return null;
+ }
+}
+
+var DiscreteEventPriority = SyncLane;
+var ContinuousEventPriority = InputContinuousLane;
+var DefaultEventPriority = DefaultLane;
+var IdleEventPriority = IdleLane;
+var currentUpdatePriority = NoLane;
+function getCurrentUpdatePriority() {
+ return currentUpdatePriority;
+}
+function setCurrentUpdatePriority(newPriority) {
+ currentUpdatePriority = newPriority;
+}
+function runWithPriority(priority, fn) {
+ var previousPriority = currentUpdatePriority;
+
+ try {
+ currentUpdatePriority = priority;
+ return fn();
+ } finally {
+ currentUpdatePriority = previousPriority;
+ }
+}
+function higherEventPriority(a, b) {
+ return a !== 0 && a < b ? a : b;
+}
+function lowerEventPriority(a, b) {
+ return a === 0 || a > b ? a : b;
+}
+function isHigherEventPriority(a, b) {
+ return a !== 0 && a < b;
+}
+function lanesToEventPriority(lanes) {
+ var lane = getHighestPriorityLane(lanes);
+
+ if (!isHigherEventPriority(DiscreteEventPriority, lane)) {
+ return DiscreteEventPriority;
+ }
+
+ if (!isHigherEventPriority(ContinuousEventPriority, lane)) {
+ return ContinuousEventPriority;
+ }
+
+ if (includesNonIdleWork(lane)) {
+ return DefaultEventPriority;
+ }
+
+ return IdleEventPriority;
+}
+
+// $FlowFixMe[method-unbinding]
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/*
+ * The `'' + value` pattern (used in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+function typeName(value) {
+ {
+ // toStringTag is needed for namespaced types like Temporal.Instant
+ var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+ var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; // $FlowFixMe[incompatible-return]
+
+ return type;
+ }
+} // $FlowFixMe[incompatible-return] only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+ {
+ try {
+ testStringCoercion(value);
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+}
+
+function testStringCoercion(value) {
+ // If you ended up here by following an exception call stack, here's what's
+ // happened: you supplied an object or symbol value to React (as a prop, key,
+ // DOM attribute, CSS property, string ref, etc.) and when React tried to
+ // coerce it to a string using `'' + value`, an exception was thrown.
+ //
+ // The most common types that will cause this exception are `Symbol` instances
+ // and Temporal objects like `Temporal.Instant`. But any object that has a
+ // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+ // exception. (Library authors do this to prevent users from using built-in
+ // numeric operators like `+` or comparison operators like `>=` because custom
+ // methods are needed to perform accurate arithmetic or comparison.)
+ //
+ // To fix the problem, coerce this object or symbol value to a string before
+ // passing it to React. The most reliable way is usually `String(value)`.
+ //
+ // To find which value is throwing, check the browser or debugger console.
+ // Before this exception was thrown, there should be `console.error` output
+ // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+ // problem and how that type was used: key, atrribute, input value prop, etc.
+ // In most cases, this console output also shows the component and its
+ // ancestor components where the exception happened.
+ //
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+
+function checkAttributeStringCoercion(value, attributeName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkKeyStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkPropStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ error('The provided `%s` prop is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', propName, typeName(value));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkCSSPropertyStringCoercion(value, propName) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkHtmlStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ 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));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+function checkFormFieldValueStringCoercion(value) {
+ {
+ if (willCoercionThrow(value)) {
+ error('Form field values (value, checked, defaultValue, or defaultChecked props)' + ' must be strings, not %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
+
+ return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+ }
+ }
+}
+
+var FunctionComponent = 0;
+var ClassComponent = 1;
+var IndeterminateComponent = 2; // Before we know whether it is function or class
+
+var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+
+var HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
+
+var HostComponent = 5;
+var HostText = 6;
+var Fragment = 7;
+var Mode = 8;
+var ContextConsumer = 9;
+var ContextProvider = 10;
+var ForwardRef = 11;
+var Profiler = 12;
+var SuspenseComponent = 13;
+var MemoComponent = 14;
+var SimpleMemoComponent = 15;
+var LazyComponent = 16;
+var IncompleteClassComponent = 17;
+var DehydratedFragment = 18;
+var SuspenseListComponent = 19;
+var ScopeComponent = 21;
+var OffscreenComponent = 22;
+var LegacyHiddenComponent = 23;
+var CacheComponent = 24;
+var TracingMarkerComponent = 25;
+var HostHoistable = 26;
+var HostSingleton = 27;
+
+var randomKey = Math.random().toString(36).slice(2);
+var internalInstanceKey = '__reactFiber$' + randomKey;
+var internalPropsKey = '__reactProps$' + randomKey;
+var internalContainerInstanceKey = '__reactContainer$' + randomKey;
+var internalEventHandlersKey = '__reactEvents$' + randomKey;
+var internalEventHandlerListenersKey = '__reactListeners$' + randomKey;
+var internalEventHandlesSetKey = '__reactHandles$' + randomKey;
+var internalRootNodeResourcesKey = '__reactResources$' + randomKey;
+var internalHoistableMarker = '__reactMarker$' + randomKey;
+function detachDeletedInstance(node) {
+ // TODO: This function is only called on host components. I don't think all of
+ // these fields are relevant.
+ delete node[internalInstanceKey];
+ delete node[internalPropsKey];
+ delete node[internalEventHandlersKey];
+ delete node[internalEventHandlerListenersKey];
+ delete node[internalEventHandlesSetKey];
+}
+function precacheFiberNode(hostInst, node) {
+ node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+ // $FlowFixMe[prop-missing]
+ node[internalContainerInstanceKey] = hostRoot;
+}
+function unmarkContainerAsRoot(node) {
+ // $FlowFixMe[prop-missing]
+ node[internalContainerInstanceKey] = null;
+}
+function isContainerMarkedAsRoot(node) {
+ // $FlowFixMe[prop-missing]
+ return !!node[internalContainerInstanceKey];
+} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
+// If the target node is part of a hydrated or not yet rendered subtree, then
+// this may also return a SuspenseComponent or HostRoot to indicate that.
+// Conceptually the HostRoot fiber is a child of the Container node. So if you
+// pass the Container node as the targetNode, you will not actually get the
+// HostRoot back. To get to the HostRoot, you need to pass a child of it.
+// The same thing applies to Suspense boundaries.
+
+function getClosestInstanceFromNode(targetNode) {
+ var targetInst = targetNode[internalInstanceKey];
+
+ if (targetInst) {
+ // Don't return HostRoot or SuspenseComponent here.
+ return targetInst;
+ } // If the direct event target isn't a React owned DOM node, we need to look
+ // to see if one of its parents is a React owned DOM node.
+
+
+ var parentNode = targetNode.parentNode;
+
+ while (parentNode) {
+ // We'll check if this is a container root that could include
+ // React nodes in the future. We need to check this first because
+ // if we're a child of a dehydrated container, we need to first
+ // find that inner container before moving on to finding the parent
+ // instance. Note that we don't check this field on the targetNode
+ // itself because the fibers are conceptually between the container
+ // node and the first child. It isn't surrounding the container node.
+ // If it's not a container, we check if it's an instance.
+ targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];
+
+ if (targetInst) {
+ // Since this wasn't the direct target of the event, we might have
+ // stepped past dehydrated DOM nodes to get here. However they could
+ // also have been non-React nodes. We need to answer which one.
+ // If we the instance doesn't have any children, then there can't be
+ // a nested suspense boundary within it. So we can use this as a fast
+ // bailout. Most of the time, when people add non-React children to
+ // the tree, it is using a ref to a child-less DOM node.
+ // Normally we'd only need to check one of the fibers because if it
+ // has ever gone from having children to deleting them or vice versa
+ // it would have deleted the dehydrated boundary nested inside already.
+ // However, since the HostRoot starts out with an alternate it might
+ // have one on the alternate so we need to check in case this was a
+ // root.
+ var alternate = targetInst.alternate;
+
+ if (targetInst.child !== null || alternate !== null && alternate.child !== null) {
+ // Next we need to figure out if the node that skipped past is
+ // nested within a dehydrated boundary and if so, which one.
+ var suspenseInstance = getParentSuspenseInstance(targetNode);
+
+ while (suspenseInstance !== null) {
+ // We found a suspense instance. That means that we haven't
+ // hydrated it yet. Even though we leave the comments in the
+ // DOM after hydrating, and there are boundaries in the DOM
+ // that could already be hydrated, we wouldn't have found them
+ // through this pass since if the target is hydrated it would
+ // have had an internalInstanceKey on it.
+ // Let's get the fiber associated with the SuspenseComponent
+ // as the deepest instance.
+ // $FlowFixMe[prop-missing]
+ var targetSuspenseInst = suspenseInstance[internalInstanceKey];
+
+ if (targetSuspenseInst) {
+ return targetSuspenseInst;
+ } // If we don't find a Fiber on the comment, it might be because
+ // we haven't gotten to hydrate it yet. There might still be a
+ // parent boundary that hasn't above this one so we need to find
+ // the outer most that is known.
+
+
+ suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
+ // host component also hasn't hydrated yet. We can return it
+ // below since it will bail out on the isMounted check later.
+ }
+ }
+
+ return targetInst;
+ }
+
+ targetNode = parentNode;
+ parentNode = targetNode.parentNode;
+ }
+
+ return null;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+
+function getInstanceFromNode$1(node) {
+ var inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+
+ if (inst) {
+ var tag = inst.tag;
+
+ if (tag === HostComponent || tag === HostText || tag === SuspenseComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostRoot) {
+ return inst;
+ } else {
+ return null;
+ }
+ }
+
+ return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+
+function getNodeFromInstance(inst) {
+ var tag = inst.tag;
+
+ if (tag === HostComponent || (tag === HostHoistable ) || (tag === HostSingleton ) || tag === HostText) {
+ // In Fiber this, is just the state node right now. We assume it will be
+ // a host component or host text.
+ return inst.stateNode;
+ } // Without this first invariant, passing a non-DOM-component triggers the next
+ // invariant for a missing parent, which is super confusing.
+
+
+ throw new Error('getNodeFromInstance: Invalid argument.');
+}
+function getFiberCurrentPropsFromNode(node) {
+ return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+ node[internalPropsKey] = props;
+}
+function getEventListenerSet(node) {
+ var elementListenerSet = node[internalEventHandlersKey];
+
+ if (elementListenerSet === undefined) {
+ elementListenerSet = node[internalEventHandlersKey] = new Set();
+ }
+
+ return elementListenerSet;
+}
+function getResourcesFromRoot(root) {
+ var resources = root[internalRootNodeResourcesKey];
+
+ if (!resources) {
+ resources = root[internalRootNodeResourcesKey] = {
+ hoistableStyles: new Map(),
+ hoistableScripts: new Map()
+ };
+ }
+
+ return resources;
+}
+function isMarkedHoistable(node) {
+ return !!node[internalHoistableMarker];
+}
+function markNodeAsHoistable(node) {
+ node[internalHoistableMarker] = true;
+}
+function isOwnedInstance(node) {
+ return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
+}
+
+// Below code forked from dom-accessibility-api
+var tagToRoleMappings = {
+ ARTICLE: 'article',
+ ASIDE: 'complementary',
+ BODY: 'document',
+ BUTTON: 'button',
+ DATALIST: 'listbox',
+ DD: 'definition',
+ DETAILS: 'group',
+ DIALOG: 'dialog',
+ DT: 'term',
+ FIELDSET: 'group',
+ FIGURE: 'figure',
+ // WARNING: Only with an accessible name
+ FORM: 'form',
+ FOOTER: 'contentinfo',
+ H1: 'heading',
+ H2: 'heading',
+ H3: 'heading',
+ H4: 'heading',
+ H5: 'heading',
+ H6: 'heading',
+ HEADER: 'banner',
+ HR: 'separator',
+ LEGEND: 'legend',
+ LI: 'listitem',
+ MATH: 'math',
+ MAIN: 'main',
+ MENU: 'list',
+ NAV: 'navigation',
+ OL: 'list',
+ OPTGROUP: 'group',
+ // WARNING: Only in certain context
+ OPTION: 'option',
+ OUTPUT: 'status',
+ PROGRESS: 'progressbar',
+ // WARNING: Only with an accessible name
+ SECTION: 'region',
+ SUMMARY: 'button',
+ TABLE: 'table',
+ TBODY: 'rowgroup',
+ TEXTAREA: 'textbox',
+ TFOOT: 'rowgroup',
+ // WARNING: Only in certain context
+ TD: 'cell',
+ TH: 'columnheader',
+ THEAD: 'rowgroup',
+ TR: 'row',
+ UL: 'list'
+};
+
+function getImplicitRole(element) {
+ var mappedByTag = tagToRoleMappings[element.tagName];
+
+ if (mappedByTag !== undefined) {
+ return mappedByTag;
+ }
+
+ switch (element.tagName) {
+ case 'A':
+ case 'AREA':
+ case 'LINK':
+ if (element.hasAttribute('href')) {
+ return 'link';
+ }
+
+ break;
+
+ case 'IMG':
+ if ((element.getAttribute('alt') || '').length > 0) {
+ return 'img';
+ }
+
+ break;
+
+ case 'INPUT':
+ {
+ var type = element.type;
+
+ switch (type) {
+ case 'button':
+ case 'image':
+ case 'reset':
+ case 'submit':
+ return 'button';
+
+ case 'checkbox':
+ case 'radio':
+ return type;
+
+ case 'range':
+ return 'slider';
+
+ case 'email':
+ case 'tel':
+ case 'text':
+ case 'url':
+ if (element.hasAttribute('list')) {
+ return 'combobox';
+ }
+
+ return 'textbox';
+
+ case 'search':
+ if (element.hasAttribute('list')) {
+ return 'combobox';
+ }
+
+ return 'searchbox';
+
+ default:
+ return null;
+ }
+ }
+
+ case 'SELECT':
+ if (element.hasAttribute('multiple') || element.size > 1) {
+ return 'listbox';
+ }
+
+ return 'combobox';
+ }
+
+ return null;
+}
+
+function getExplicitRoles(element) {
+ var role = element.getAttribute('role');
+
+ if (role) {
+ return role.trim().split(' ');
+ }
+
+ return null;
+} // https://w3c.github.io/html-aria/#document-conformance-requirements-for-use-of-aria-attributes-in-html
+
+
+function hasRole(element, role) {
+ var explicitRoles = getExplicitRoles(element);
+
+ if (explicitRoles !== null && explicitRoles.indexOf(role) >= 0) {
+ return true;
+ }
+
+ return role === getImplicitRole(element);
+}
+
+var allNativeEvents = new Set();
+/**
+ * Mapping from registration name to event name
+ */
+
+
+var registrationNameDependencies = {};
+/**
+ * Mapping from lowercase registration names to the properly cased version,
+ * used to warn in the case of missing event handlers. Available
+ * only in __DEV__.
+ * @type {Object}
+ */
+
+var possibleRegistrationNames = {} ; // Trust the developer to only use possibleRegistrationNames in true
+
+function registerTwoPhaseEvent(registrationName, dependencies) {
+ registerDirectEvent(registrationName, dependencies);
+ registerDirectEvent(registrationName + 'Capture', dependencies);
+}
+function registerDirectEvent(registrationName, dependencies) {
+ {
+ if (registrationNameDependencies[registrationName]) {
+ error('EventRegistry: More than one plugin attempted to publish the same ' + 'registration name, `%s`.', registrationName);
+ }
+ }
+
+ registrationNameDependencies[registrationName] = dependencies;
+
+ {
+ var lowerCasedName = registrationName.toLowerCase();
+ possibleRegistrationNames[lowerCasedName] = registrationName;
+
+ if (registrationName === 'onDoubleClick') {
+ possibleRegistrationNames.ondblclick = registrationName;
+ }
+ }
+
+ for (var i = 0; i < dependencies.length; i++) {
+ allNativeEvents.add(dependencies[i]);
+ }
+}
+
+var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+var hasReadOnlyValue = {
+ button: true,
+ checkbox: true,
+ image: true,
+ hidden: true,
+ radio: true,
+ reset: true,
+ submit: true
+};
+function checkControlledValueProps(tagName, props) {
+ {
+ if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
+ error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+
+ if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
+ error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+ }
+ }
+}
+
+/* eslint-disable max-len */
+
+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";
+/* eslint-enable max-len */
+
+var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
+var illegalAttributeNameCache = {};
+var validatedAttributeNameCache = {};
+function isAttributeNameSafe(attributeName) {
+ if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
+ return true;
+ }
+
+ if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
+ return false;
+ }
+
+ if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+ validatedAttributeNameCache[attributeName] = true;
+ return true;
+ }
+
+ illegalAttributeNameCache[attributeName] = true;
+
+ {
+ error('Invalid attribute name: `%s`', attributeName);
+ }
+
+ return false;
+}
+
+/**
+ * Get the value for a attribute on a node. Only used in DEV for SSR validation.
+ * The third argument is used as a hint of what the expected value is. Some
+ * attributes have multiple equivalent values.
+ */
+
+function getValueForAttribute(node, name, expected) {
+ {
+ if (!isAttributeNameSafe(name)) {
+ return;
+ }
+
+ if (!node.hasAttribute(name)) {
+ // shouldRemoveAttribute
+ switch (typeof expected) {
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ return expected;
+
+ case 'boolean':
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix !== 'data-' && prefix !== 'aria-') {
+ return expected;
+ }
+ }
+ }
+
+ return expected === undefined ? undefined : null;
+ }
+
+ var value = node.getAttribute(name);
+
+ {
+ checkAttributeStringCoercion(expected, name);
+ }
+
+ if (value === '' + expected) {
+ return expected;
+ }
+
+ return value;
+ }
+}
+function getValueForAttributeOnCustomComponent(node, name, expected) {
+ {
+ if (!isAttributeNameSafe(name)) {
+ return;
+ }
+
+ if (!node.hasAttribute(name)) {
+ // shouldRemoveAttribute
+ switch (typeof expected) {
+ case 'symbol':
+ case 'object':
+ // Symbols and objects are ignored when they're emitted so
+ // it would be expected that they end up not having an attribute.
+ return expected;
+
+ case 'function':
+ {
+ return expected;
+ }
+
+ case 'boolean':
+ {
+ if (expected === false) {
+ return expected;
+ }
+ }
+
+ }
+
+ return expected === undefined ? undefined : null;
+ }
+
+ var value = node.getAttribute(name);
+
+ {
+ if (value === '' && expected === true) {
+ return true;
+ }
+ }
+
+ {
+ checkAttributeStringCoercion(expected, name);
+ }
+
+ if (value === '' + expected) {
+ return expected;
+ }
+
+ return value;
+ }
+}
+function setValueForAttribute(node, name, value) {
+ if (isAttributeNameSafe(name)) {
+ // If the prop isn't in the special list, treat it as a simple attribute.
+ // shouldRemoveAttribute
+ if (value === null) {
+ node.removeAttribute(name);
+ return;
+ }
+
+ switch (typeof value) {
+ case 'undefined':
+ case 'function':
+ case 'symbol':
+ // eslint-disable-line
+ node.removeAttribute(name);
+ return;
+
+ case 'boolean':
+ {
+ var prefix = name.toLowerCase().slice(0, 5);
+
+ if (prefix !== 'data-' && prefix !== 'aria-') {
+ node.removeAttribute(name);
+ return;
+ }
+ }
+ }
+
+ {
+ checkAttributeStringCoercion(value, name);
+ }
+
+ node.setAttribute(name, '' + value);
+ }
+}
+function setValueForKnownAttribute(node, name, value) {
+ if (value === null) {
+ node.removeAttribute(name);
+ return;
+ }
+
+ switch (typeof value) {
+ case 'undefined':
+ case 'function':
+ case 'symbol':
+ case 'boolean':
+ {
+ node.removeAttribute(name);
+ return;
+ }
+ }
+
+ {
+ checkAttributeStringCoercion(value, name);
+ }
+
+ node.setAttribute(name, '' + value);
+}
+function setValueForNamespacedAttribute(node, namespace, name, value) {
+ if (value === null) {
+ node.removeAttribute(name);
+ return;
+ }
+
+ switch (typeof value) {
+ case 'undefined':
+ case 'function':
+ case 'symbol':
+ case 'boolean':
+ {
+ node.removeAttribute(name);
+ return;
+ }
+ }
+
+ {
+ checkAttributeStringCoercion(value, name);
+ }
+
+ node.setAttributeNS(namespace, name, '' + value);
+}
+function setValueForPropertyOnCustomComponent(node, name, value) {
+ if (name[0] === 'o' && name[1] === 'n') {
+ var useCapture = name.endsWith('Capture');
+ var eventName = name.slice(2, useCapture ? name.length - 7 : undefined);
+ var prevProps = getFiberCurrentPropsFromNode(node);
+ var prevValue = prevProps != null ? prevProps[name] : null;
+
+ if (typeof prevValue === 'function') {
+ node.removeEventListener(eventName, prevValue, useCapture);
+ }
+
+ if (typeof value === 'function') {
+ if (typeof prevValue !== 'function' && prevValue !== null) {
+ // If we previously assigned a non-function type into this node, then
+ // remove it when switching to event listener mode.
+ if (name in node) {
+ node[name] = null;
+ } else if (node.hasAttribute(name)) {
+ node.removeAttribute(name);
+ }
+ } // $FlowFixMe[incompatible-cast] value can't be casted to EventListener.
+
+
+ node.addEventListener(eventName, value, useCapture);
+ return;
+ }
+ }
+
+ if (name in node) {
+ node[name] = value;
+ return;
+ }
+
+ if (value === true) {
+ node.setAttribute(name, '');
+ return;
+ } // From here, it's the same as any attribute
+
+
+ setValueForAttribute(node, name, value);
+}
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+var REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+var REACT_MEMO_TYPE = Symbol.for('react.memo');
+var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+var REACT_SCOPE_TYPE = Symbol.for('react.scope');
+var REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
+var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+var REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+var REACT_CACHE_TYPE = Symbol.for('react.cache');
+var REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+var REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+var FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== 'object') {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === 'function') {
+ return maybeIterator;
+ }
+
+ return null;
+}
+
+var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher;
+var prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+ {
+ if (prefix === undefined) {
+ // Extract the VM specific prefix used by each line.
+ try {
+ throw Error();
+ } catch (x) {
+ var match = x.stack.trim().match(/\n( *(at )?)/);
+ prefix = match && match[1] || '';
+ }
+ } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+ return '\n' + prefix + name;
+ }
+}
+var reentry = false;
+var componentFrameCache;
+
+{
+ var PossiblyWeakMap$1 = typeof WeakMap === 'function' ? WeakMap : Map;
+ componentFrameCache = new PossiblyWeakMap$1();
+}
+
+function describeNativeComponentFrame(fn, construct) {
+ // If something asked for a stack inside a fake render, it should get ignored.
+ if (!fn || reentry) {
+ return '';
+ }
+
+ {
+ var frame = componentFrameCache.get(fn);
+
+ if (frame !== undefined) {
+ return frame;
+ }
+ }
+
+ var control;
+ reentry = true;
+ var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+ Error.prepareStackTrace = undefined;
+ var previousDispatcher;
+
+ {
+ previousDispatcher = ReactCurrentDispatcher$2.current; // Set the dispatcher in DEV because this might be call in the render function
+ // for warnings.
+
+ ReactCurrentDispatcher$2.current = null;
+ disableLogs();
+ }
+
+ try {
+ // This should throw.
+ if (construct) {
+ // Something should be setting the props in the constructor.
+ var Fake = function () {
+ throw Error();
+ }; // $FlowFixMe[prop-missing]
+
+
+ Object.defineProperty(Fake.prototype, 'props', {
+ set: function () {
+ // We use a throwing setter instead of frozen or non-writable props
+ // because that won't throw in a non-strict mode function.
+ throw Error();
+ }
+ });
+
+ if (typeof Reflect === 'object' && Reflect.construct) {
+ // We construct a different control for this case to include any extra
+ // frames added by the construct call.
+ try {
+ Reflect.construct(Fake, []);
+ } catch (x) {
+ control = x;
+ }
+
+ Reflect.construct(fn, [], Fake);
+ } else {
+ try {
+ Fake.call();
+ } catch (x) {
+ control = x;
+ } // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+ fn.call(Fake.prototype);
+ }
+ } else {
+ try {
+ throw Error();
+ } catch (x) {
+ control = x;
+ } // TODO(luna): This will currently only throw if the function component
+ // tries to access React/ReactDOM/props. We should probably make this throw
+ // in simple components too
+
+
+ fn();
+ }
+ } catch (sample) {
+ // This is inlined manually because closure doesn't do it for us.
+ if (sample && control && typeof sample.stack === 'string') {
+ // This extracts the first frame from the sample that isn't also in the control.
+ // Skipping one frame that we assume is the frame that calls the two.
+ var sampleLines = sample.stack.split('\n');
+ var controlLines = control.stack.split('\n');
+ var s = sampleLines.length - 1;
+ var c = controlLines.length - 1;
+
+ while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+ // We expect at least one stack frame to be shared.
+ // Typically this will be the root most one. However, stack frames may be
+ // cut off due to maximum stack limits. In this case, one maybe cut off
+ // earlier than the other. We assume that the sample is longer or the same
+ // and there for cut off earlier. So we should find the root most frame in
+ // the sample somewhere in the control.
+ c--;
+ }
+
+ for (; s >= 1 && c >= 0; s--, c--) {
+ // Next we find the first one that isn't the same which should be the
+ // frame that called our sample function and the control.
+ if (sampleLines[s] !== controlLines[c]) {
+ // In V8, the first line is describing the message but other VMs don't.
+ // If we're about to return the first line, and the control is also on the same
+ // line, that's a pretty good indicator that our sample threw at same line as
+ // the control. I.e. before we entered the sample frame. So we ignore this result.
+ // This can happen if you passed a class to function component, or non-function.
+ if (s !== 1 || c !== 1) {
+ do {
+ s--;
+ c--; // We may still have similar intermediate frames from the construct call.
+ // The next one that isn't the same should be our match though.
+
+ if (c < 0 || sampleLines[s] !== controlLines[c]) {
+ // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+ var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled ""
+ // but we have a user-provided "displayName"
+ // splice it in to make the stack more readable.
+
+
+ if (fn.displayName && _frame.includes('')) {
+ _frame = _frame.replace('', fn.displayName);
+ }
+
+ {
+ if (typeof fn === 'function') {
+ componentFrameCache.set(fn, _frame);
+ }
+ } // Return the line we found.
+
+
+ return _frame;
+ }
+ } while (s >= 1 && c >= 0);
+ }
+
+ break;
+ }
+ }
+ }
+ } finally {
+ reentry = false;
+
+ {
+ ReactCurrentDispatcher$2.current = previousDispatcher;
+ reenableLogs();
+ }
+
+ Error.prepareStackTrace = previousPrepareStackTrace;
+ } // Fallback to just using the name if we couldn't make it throw.
+
+
+ var name = fn ? fn.displayName || fn.name : '';
+ var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+ {
+ if (typeof fn === 'function') {
+ componentFrameCache.set(fn, syntheticFrame);
+ }
+ }
+
+ return syntheticFrame;
+}
+
+function describeClassComponentFrame(ctor, source, ownerFn) {
+ {
+ return describeNativeComponentFrame(ctor, true);
+ }
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+ {
+ return describeNativeComponentFrame(fn, false);
+ }
+}
+
+function shouldConstruct$1(Component) {
+ var prototype = Component.prototype;
+ return !!(prototype && prototype.isReactComponent);
+}
+
+function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+
+ if (type == null) {
+ return '';
+ }
+
+ if (typeof type === 'function') {
+ {
+ return describeNativeComponentFrame(type, shouldConstruct$1(type));
+ }
+ }
+
+ if (typeof type === 'string') {
+ return describeBuiltInComponentFrame(type);
+ }
+
+ switch (type) {
+ case REACT_SUSPENSE_TYPE:
+ return describeBuiltInComponentFrame('Suspense');
+
+ case REACT_SUSPENSE_LIST_TYPE:
+ return describeBuiltInComponentFrame('SuspenseList');
+ }
+
+ if (typeof type === 'object') {
+ switch (type.$$typeof) {
+ case REACT_FORWARD_REF_TYPE:
+ return describeFunctionComponentFrame(type.render);
+
+ case REACT_MEMO_TYPE:
+ // Memo may contain any component type so we recursively resolve it.
+ return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+
+ case REACT_LAZY_TYPE:
+ {
+ var lazyComponent = type;
+ var payload = lazyComponent._payload;
+ var init = lazyComponent._init;
+
+ try {
+ // Lazy may contain any component type so we recursively resolve it.
+ return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+ } catch (x) {}
+ }
+ }
+ }
+
+ return '';
+}
+
+function describeFiber(fiber) {
+
+ switch (fiber.tag) {
+ case HostHoistable:
+ case HostSingleton:
+ case HostComponent:
+ return describeBuiltInComponentFrame(fiber.type);
+
+ case LazyComponent:
+ return describeBuiltInComponentFrame('Lazy');
+
+ case SuspenseComponent:
+ return describeBuiltInComponentFrame('Suspense');
+
+ case SuspenseListComponent:
+ return describeBuiltInComponentFrame('SuspenseList');
+
+ case FunctionComponent:
+ case IndeterminateComponent:
+ case SimpleMemoComponent:
+ return describeFunctionComponentFrame(fiber.type);
+
+ case ForwardRef:
+ return describeFunctionComponentFrame(fiber.type.render);
+
+ case ClassComponent:
+ return describeClassComponentFrame(fiber.type);
+
+ default:
+ return '';
+ }
+}
+
+function getStackByFiberInDevAndProd(workInProgress) {
+ try {
+ var info = '';
+ var node = workInProgress;
+
+ do {
+ info += describeFiber(node); // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+ node = node.return;
+ } while (node);
+
+ return info;
+ } catch (x) {
+ return '\nError generating stack: ' + x.message + '\n' + x.stack;
+ }
+}
+
+function getWrappedName$1(outerType, innerType, wrapperName) {
+ var displayName = outerType.displayName;
+
+ if (displayName) {
+ return displayName;
+ }
+
+ var functionName = innerType.displayName || innerType.name || '';
+ return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName$1(type) {
+ return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+ if (type == null) {
+ // Host root, text node or just invalid type.
+ return null;
+ }
+
+ {
+ if (typeof type.tag === 'number') {
+ error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+ }
+ }
+
+ if (typeof type === 'function') {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === 'string') {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return 'Fragment';
+
+ case REACT_PORTAL_TYPE:
+ return 'Portal';
+
+ case REACT_PROFILER_TYPE:
+ return 'Profiler';
+
+ case REACT_STRICT_MODE_TYPE:
+ return 'StrictMode';
+
+ case REACT_SUSPENSE_TYPE:
+ return 'Suspense';
+
+ case REACT_SUSPENSE_LIST_TYPE:
+ return 'SuspenseList';
+
+ case REACT_CACHE_TYPE:
+ {
+ return 'Cache';
+ }
+
+ }
+
+ if (typeof type === 'object') {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ var context = type;
+ return getContextName$1(context) + '.Consumer';
+
+ case REACT_PROVIDER_TYPE:
+ var provider = type;
+ return getContextName$1(provider._context) + '.Provider';
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName$1(type, type.render, 'ForwardRef');
+
+ case REACT_MEMO_TYPE:
+ var outerName = type.displayName || null;
+
+ if (outerName !== null) {
+ return outerName;
+ }
+
+ return getComponentNameFromType(type.type) || 'Memo';
+
+ case REACT_LAZY_TYPE:
+ {
+ var lazyComponent = type;
+ var payload = lazyComponent._payload;
+ var init = lazyComponent._init;
+
+ try {
+ return getComponentNameFromType(init(payload));
+ } catch (x) {
+ return null;
+ }
+ }
+
+ case REACT_SERVER_CONTEXT_TYPE:
+ {
+ var context2 = type;
+ return (context2.displayName || context2._globalName) + '.Provider';
+ }
+
+ }
+ }
+
+ return null;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || '';
+ return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+} // Keep in sync with shared/getComponentNameFromType
+
+
+function getContextName(type) {
+ return type.displayName || 'Context';
+}
+
+function getComponentNameFromFiber(fiber) {
+ var tag = fiber.tag,
+ type = fiber.type;
+
+ switch (tag) {
+ case CacheComponent:
+ return 'Cache';
+
+ case ContextConsumer:
+ var context = type;
+ return getContextName(context) + '.Consumer';
+
+ case ContextProvider:
+ var provider = type;
+ return getContextName(provider._context) + '.Provider';
+
+ case DehydratedFragment:
+ return 'DehydratedFragment';
+
+ case ForwardRef:
+ return getWrappedName(type, type.render, 'ForwardRef');
+
+ case Fragment:
+ return 'Fragment';
+
+ case HostHoistable:
+ case HostSingleton:
+ case HostComponent:
+ // Host component type is the display name (e.g. "div", "View")
+ return type;
+
+ case HostPortal:
+ return 'Portal';
+
+ case HostRoot:
+ return 'Root';
+
+ case HostText:
+ return 'Text';
+
+ case LazyComponent:
+ // Name comes from the type in this case; we don't have a tag.
+ return getComponentNameFromType(type);
+
+ case Mode:
+ if (type === REACT_STRICT_MODE_TYPE) {
+ // Don't be less specific than shared/getComponentNameFromType
+ return 'StrictMode';
+ }
+
+ return 'Mode';
+
+ case OffscreenComponent:
+ return 'Offscreen';
+
+ case Profiler:
+ return 'Profiler';
+
+ case ScopeComponent:
+ return 'Scope';
+
+ case SuspenseComponent:
+ return 'Suspense';
+
+ case SuspenseListComponent:
+ return 'SuspenseList';
+
+ case TracingMarkerComponent:
+ return 'TracingMarker';
+ // The display name for this tags come from the user-provided type:
+
+ case ClassComponent:
+ case FunctionComponent:
+ case IncompleteClassComponent:
+ case IndeterminateComponent:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ if (typeof type === 'function') {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === 'string') {
+ return type;
+ }
+
+ break;
+
+ }
+
+ return null;
+}
+
+var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+var current = null;
+var isRendering = false;
+function getCurrentFiberOwnerNameInDevOrNull() {
+ {
+ if (current === null) {
+ return null;
+ }
+
+ var owner = current._debugOwner;
+
+ if (owner !== null && typeof owner !== 'undefined') {
+ return getComponentNameFromFiber(owner);
+ }
+ }
+
+ return null;
+}
+
+function getCurrentFiberStackInDev() {
+ {
+ if (current === null) {
+ return '';
+ } // Safe because if current fiber exists, we are reconciling,
+ // and it is guaranteed to be the work-in-progress version.
+
+
+ return getStackByFiberInDevAndProd(current);
+ }
+}
+
+function resetCurrentFiber() {
+ {
+ ReactDebugCurrentFrame$1.getCurrentStack = null;
+ current = null;
+ isRendering = false;
+ }
+}
+function setCurrentFiber(fiber) {
+ {
+ ReactDebugCurrentFrame$1.getCurrentStack = fiber === null ? null : getCurrentFiberStackInDev;
+ current = fiber;
+ isRendering = false;
+ }
+}
+function getCurrentFiber() {
+ {
+ return current;
+ }
+}
+function setIsRendering(rendering) {
+ {
+ isRendering = rendering;
+ }
+}
+
+// around this limitation, we use an opaque type that can only be obtained by
+// passing the value through getToStringValue first.
+
+function toString(value) {
+ // The coercion safety check is performed in getToStringValue().
+ // eslint-disable-next-line react-internal/safe-string-coercion
+ return '' + value;
+}
+function getToStringValue(value) {
+ switch (typeof value) {
+ case 'boolean':
+ case 'number':
+ case 'string':
+ case 'undefined':
+ return value;
+
+ case 'object':
+ {
+ checkFormFieldValueStringCoercion(value);
+ }
+
+ return value;
+
+ default:
+ // function, symbol are assigned as empty strings
+ return '';
+ }
+}
+
+function isCheckable(elem) {
+ var type = elem.type;
+ var nodeName = elem.nodeName;
+ return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
+}
+
+function getTracker(node) {
+ return node._valueTracker;
+}
+
+function detachTracker(node) {
+ node._valueTracker = null;
+}
+
+function getValueFromNode(node) {
+ var value = '';
+
+ if (!node) {
+ return value;
+ }
+
+ if (isCheckable(node)) {
+ value = node.checked ? 'true' : 'false';
+ } else {
+ value = node.value;
+ }
+
+ return value;
+}
+
+function trackValueOnNode(node) {
+ var valueField = isCheckable(node) ? 'checked' : 'value';
+ var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+
+ {
+ checkFormFieldValueStringCoercion(node[valueField]);
+ }
+
+ var currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
+ // and don't track value will cause over reporting of changes,
+ // but it's better then a hard failure
+ // (needed for certain tests that spyOn input values and Safari)
+
+ if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
+ return;
+ }
+
+ var get = descriptor.get,
+ set = descriptor.set;
+ Object.defineProperty(node, valueField, {
+ configurable: true,
+ // $FlowFixMe[missing-this-annot]
+ get: function () {
+ return get.call(this);
+ },
+ // $FlowFixMe[missing-local-annot]
+ // $FlowFixMe[missing-this-annot]
+ set: function (value) {
+ {
+ checkFormFieldValueStringCoercion(value);
+ }
+
+ currentValue = '' + value;
+ set.call(this, value);
+ }
+ }); // We could've passed this the first time
+ // but it triggers a bug in IE11 and Edge 14/15.
+ // Calling defineProperty() again should be equivalent.
+ // https://github.com/facebook/react/issues/11768
+
+ Object.defineProperty(node, valueField, {
+ enumerable: descriptor.enumerable
+ });
+ var tracker = {
+ getValue: function () {
+ return currentValue;
+ },
+ setValue: function (value) {
+ {
+ checkFormFieldValueStringCoercion(value);
+ }
+
+ currentValue = '' + value;
+ },
+ stopTracking: function () {
+ detachTracker(node);
+ delete node[valueField];
+ }
+ };
+ return tracker;
+}
+
+function track(node) {
+ if (getTracker(node)) {
+ return;
+ }
+
+ node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node) {
+ if (!node) {
+ return false;
+ }
+
+ var tracker = getTracker(node); // if there is no tracker at this point it's unlikely
+ // that trying again will succeed
+
+ if (!tracker) {
+ return true;
+ }
+
+ var lastValue = tracker.getValue();
+ var nextValue = getValueFromNode(node);
+
+ if (nextValue !== lastValue) {
+ tracker.setValue(nextValue);
+ return true;
+ }
+
+ return false;
+}
+
+function getActiveElement(doc) {
+ doc = doc || (typeof document !== 'undefined' ? document : undefined);
+
+ if (typeof doc === 'undefined') {
+ return null;
+ }
+
+ try {
+ return doc.activeElement || doc.body;
+ } catch (e) {
+ return doc.body;
+ }
+}
+
+var didWarnValueDefaultValue$1 = false;
+var didWarnCheckedDefaultChecked = false;
+/**
+ * Implements an host component that allows setting these optional
+ * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
+ *
+ * If `checked` or `value` are not supplied (or null/undefined), user actions
+ * that affect the checked state or value will trigger updates to the element.
+ *
+ * If they are supplied (and not null/undefined), the rendered element will not
+ * trigger updates to the element. Instead, the props must change in order for
+ * the rendered element to be updated.
+ *
+ * The rendered element will be initialized as unchecked (or `defaultChecked`)
+ * with an empty value (or `defaultValue`).
+ *
+ * See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
+ */
+
+function validateInputProps(element, props) {
+ {
+ // Normally we check for undefined and null the same, but explicitly specifying both
+ // properties, at all is probably worth warning for. We could move this either direction
+ // and just make it ok to pass null or just check hasOwnProperty.
+ if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) {
+ error('%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://reactjs.org/link/controlled-components', getCurrentFiberOwnerNameInDevOrNull() || 'A component', props.type);
+
+ didWarnCheckedDefaultChecked = true;
+ }
+
+ if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue$1) {
+ error('%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://reactjs.org/link/controlled-components', getCurrentFiberOwnerNameInDevOrNull() || 'A component', props.type);
+
+ didWarnValueDefaultValue$1 = true;
+ }
+ }
+}
+function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
+ var node = element; // Temporarily disconnect the input from any radio buttons.
+ // Changing the type or name as the same time as changing the checked value
+ // needs to be atomically applied. We can only ensure that by disconnecting
+ // the name while do the mutations and then reapply the name after that's done.
+
+ node.name = '';
+
+ if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+ {
+ checkAttributeStringCoercion(type, 'type');
+ }
+
+ node.type = type;
+ } else {
+ node.removeAttribute('type');
+ }
+
+ if (value != null) {
+ if (type === 'number') {
+ if ( // $FlowFixMe[incompatible-type]
+ value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
+ // eslint-disable-next-line
+ node.value != value) {
+ node.value = toString(getToStringValue(value));
+ }
+ } else if (node.value !== toString(getToStringValue(value))) {
+ node.value = toString(getToStringValue(value));
+ }
+ } else if (type === 'submit' || type === 'reset') {
+ // Submit/reset inputs need the attribute removed completely to avoid
+ // blank-text buttons.
+ node.removeAttribute('value');
+ return;
+ }
+
+ {
+ // When syncing the value attribute, the value comes from a cascade of
+ // properties:
+ // 1. The value React property
+ // 2. The defaultValue React property
+ // 3. Otherwise there should be no change
+ if (value != null) {
+ setDefaultValue(node, type, getToStringValue(value));
+ } else if (defaultValue != null) {
+ setDefaultValue(node, type, getToStringValue(defaultValue));
+ } else if (lastDefaultValue != null) {
+ node.removeAttribute('value');
+ }
+ }
+
+ {
+ // When syncing the checked attribute, it only changes when it needs
+ // to be removed, such as transitioning from a checkbox into a text input
+ if (checked == null && defaultChecked != null) {
+ node.defaultChecked = !!defaultChecked;
+ }
+ }
+
+ if (checked != null && node.checked !== !!checked) {
+ node.checked = checked;
+ }
+
+ if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+ {
+ checkAttributeStringCoercion(name, 'name');
+ }
+
+ node.name = name;
+ } else {
+ node.removeAttribute('name');
+ }
+}
+function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
+ var node = element;
+
+ if (type != null && typeof type !== 'function' && typeof type !== 'symbol' && typeof type !== 'boolean') {
+ {
+ checkAttributeStringCoercion(type, 'type');
+ }
+
+ node.type = type;
+ }
+
+ if (value != null || defaultValue != null) {
+ var isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
+ // default value provided by the browser. See: #12872
+
+ if (isButton && (value === undefined || value === null)) {
+ return;
+ }
+
+ var defaultValueStr = defaultValue != null ? toString(getToStringValue(defaultValue)) : '';
+ var initialValue = value != null ? toString(getToStringValue(value)) : defaultValueStr; // Do not assign value if it is already set. This prevents user text input
+ // from being lost during SSR hydration.
+
+ if (!isHydrating) {
+ {
+ // When syncing the value attribute, the value property should use
+ // the wrapperState._initialValue property. This uses:
+ //
+ // 1. The value React property when present
+ // 2. The defaultValue React property when present
+ // 3. An empty string
+ if (initialValue !== node.value) {
+ node.value = initialValue;
+ }
+ }
+ }
+
+ {
+ // Otherwise, the value attribute is synchronized to the property,
+ // so we assign defaultValue to the same thing as the value property
+ // assignment step above.
+ node.defaultValue = initialValue;
+ }
+ } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+ // this is needed to work around a chrome bug where setting defaultChecked
+ // will sometimes influence the value of checked (even after detachment).
+ // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+ // We need to temporarily unset name to avoid disrupting radio button groups.
+
+
+ var checkedOrDefault = checked != null ? checked : defaultChecked; // TODO: This 'function' or 'symbol' check isn't replicated in other places
+ // so this semantic is inconsistent.
+
+ var initialChecked = typeof checkedOrDefault !== 'function' && typeof checkedOrDefault !== 'symbol' && !!checkedOrDefault; // The checked property never gets assigned. It must be manually set.
+ // We don't want to do this when hydrating so that existing user input isn't
+ // modified
+ // TODO: I'm pretty sure this is a bug because initialValueTracking won't be
+ // correct for the hydration case then.
+
+ if (!isHydrating) {
+ node.checked = !!initialChecked;
+ }
+
+ {
+ // When syncing the checked attribute, both the checked property and
+ // attribute are assigned at the same time using defaultChecked. This uses:
+ //
+ // 1. The checked React property when present
+ // 2. The defaultChecked React property when present
+ // 3. Otherwise, false
+ node.defaultChecked = !node.defaultChecked;
+ node.defaultChecked = !!initialChecked;
+ } // Name needs to be set at the end so that it applies atomically to connected radio buttons.
+
+
+ if (name != null && typeof name !== 'function' && typeof name !== 'symbol' && typeof name !== 'boolean') {
+ {
+ checkAttributeStringCoercion(name, 'name');
+ }
+
+ node.name = name;
+ }
+}
+function restoreControlledInputState(element, props) {
+ var rootNode = element;
+ updateInput(rootNode, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
+ var name = props.name;
+
+ if (props.type === 'radio' && name != null) {
+ var queryRoot = rootNode;
+
+ while (queryRoot.parentNode) {
+ queryRoot = queryRoot.parentNode;
+ } // If `rootNode.form` was non-null, then we could try `form.elements`,
+ // but that sometimes behaves strangely in IE8. We could also try using
+ // `form.getElementsByName`, but that will only return direct children
+ // and won't include inputs that use the HTML5 `form=` attribute. Since
+ // the input might not even be in a form. It might not even be in the
+ // document. Let's just use the local `querySelectorAll` to ensure we don't
+ // miss anything.
+
+
+ {
+ checkAttributeStringCoercion(name, 'name');
+ }
+
+ var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]');
+
+ for (var i = 0; i < group.length; i++) {
+ var otherNode = group[i];
+
+ if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+ continue;
+ } // This will throw if radio buttons rendered by different copies of React
+ // and the same name are rendered into the same form (same as #1939).
+ // That's probably okay; we don't support it just as we don't support
+ // mixing React radio buttons with non-React ones.
+
+
+ var otherProps = getFiberCurrentPropsFromNode(otherNode);
+
+ if (!otherProps) {
+ throw new Error('ReactDOMInput: Mixing React and non-React radio inputs with the ' + 'same `name` is not supported.');
+ } // We need update the tracked value on the named cousin since the value
+ // was changed but the input saw no event or value set
+
+
+ updateValueIfChanged(otherNode); // If this is a controlled radio button group, forcing the input that
+ // was previously checked to update will cause it to be come re-checked
+ // as appropriate.
+
+ updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
+ }
+ }
+} // In Chrome, assigning defaultValue to certain input types triggers input validation.
+// For number inputs, the display value loses trailing decimal points. For email inputs,
+// Chrome raises "The specified value is not a valid email address".
+//
+// Here we check to see if the defaultValue has actually changed, avoiding these problems
+// when the user is inputting text
+//
+// https://github.com/facebook/react/issues/7253
+
+function setDefaultValue(node, type, value) {
+ if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
+ type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
+ if (node.defaultValue !== toString(value)) {
+ node.defaultValue = toString(value);
+ }
+ }
+}
+
+var didWarnSelectedSetOnOption = false;
+var didWarnInvalidChild = false;
+var didWarnInvalidInnerHTML = false;
+/**
+ * Implements an