diff --git a/package.json b/package.json
index a693a9ff2d71240..10f3ca903bc148b 100644
--- a/package.json
+++ b/package.json
@@ -180,11 +180,11 @@
"random-seed": "0.3.0",
"react": "18.2.0",
"react-17": "npm:react@17.0.2",
- "react-builtin": "npm:react@18.3.0-next-2655c9354-20221121",
+ "react-builtin": "npm:react@18.3.0-next-3ba7add60-20221201",
"react-dom": "18.2.0",
"react-dom-17": "npm:react-dom@17.0.2",
- "react-dom-builtin": "npm:react-dom@18.3.0-next-2655c9354-20221121",
- "react-server-dom-webpack": "18.3.0-next-2655c9354-20221121",
+ "react-dom-builtin": "npm:react-dom@18.3.0-next-3ba7add60-20221201",
+ "react-server-dom-webpack": "18.3.0-next-3ba7add60-20221201",
"react-ssr-prepass": "1.0.8",
"react-virtualized": "9.22.3",
"relay-compiler": "13.0.2",
diff --git a/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js b/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js
index d5354a3cd0ab9b9..6876273988b38aa 100644
--- a/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js
+++ b/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js
@@ -17,7 +17,7 @@ if (process.env.NODE_ENV !== "production") {
var React = require('react');
var ReactDOM = require('react-dom');
-var ReactVersion = '18.3.0-next-2655c9354-20221121';
+var ReactVersion = '18.3.0-next-3ba7add60-20221201';
var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
@@ -2191,8 +2191,13 @@ function preinit(href, options) {
return;
}
- var resources = currentResources;
+ preinitImpl(currentResources, href, options);
+} // On the server, preinit may be called outside of render when sending an
+// external SSR runtime as part of the initial resources payload. Since this
+// is an internal React call, we do not need to use the resources stack.
+
+function preinitImpl(resources, href, options) {
{
validatePreinitArguments(href, options);
}
@@ -2839,7 +2844,7 @@ function cleanupAfterRender(previousDispatcher) {
finishRenderingResources();
ReactDOMCurrentDispatcher.current = previousDispatcher;
} // Used to distinguish these contexts from ones used in other renderers.
-
+var ScriptStreamingFormat = 0;
var startInlineScript = stringToPrecomputedChunk('');
var startScriptSrc = stringToPrecomputedChunk('');
+var completeSegmentScriptEnd = stringToPrecomputedChunk('")');
function writeCompletedSegmentInstruction(destination, responseState, contentSegmentID) {
- writeChunk(destination, responseState.startInlineScript);
- if (!responseState.sentCompleteSegmentFunction) {
- // The first time we write this, we'll need to include the full implementation.
- responseState.sentCompleteSegmentFunction = true;
- writeChunk(destination, completeSegmentScript1Full);
- } else {
- // Future calls can just reuse the same function.
- writeChunk(destination, completeSegmentScript1Partial);
- }
+ {
+ writeChunk(destination, responseState.startInlineScript);
+
+ if (!responseState.sentCompleteSegmentFunction) {
+ // The first time we write this, we'll need to include the full implementation.
+ responseState.sentCompleteSegmentFunction = true;
+ writeChunk(destination, completeSegmentScript1Full);
+ } else {
+ // Future calls can just reuse the same function.
+ writeChunk(destination, completeSegmentScript1Partial);
+ }
+ } // Write function arguments, which are string literals
+
writeChunk(destination, responseState.segmentPrefix);
var formattedID = stringToChunk(contentSegmentID.toString(16));
writeChunk(destination, formattedID);
- writeChunk(destination, completeSegmentScript2);
+
+ {
+ writeChunk(destination, completeSegmentScript2);
+ }
+
writeChunk(destination, responseState.placeholderPrefix);
writeChunk(destination, formattedID);
- return writeChunkAndReturn(destination, completeSegmentScript3);
+
+ {
+ return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+ }
}
var completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + ';$RC("');
var completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
@@ -4559,9 +4578,9 @@ var completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(complet
var completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + ';$RR("');
var completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
var completeBoundaryScript2 = stringToPrecomputedChunk('","');
-var completeBoundaryScript2a = stringToPrecomputedChunk('",');
-var completeBoundaryScript3 = stringToPrecomputedChunk('"');
-var completeBoundaryScript4 = stringToPrecomputedChunk(')');
+var completeBoundaryScript3a = stringToPrecomputedChunk('",');
+var completeBoundaryScript3b = stringToPrecomputedChunk('"');
+var completeBoundaryScriptEnd = stringToPrecomputedChunk(')');
function writeCompletedBoundaryInstruction(destination, responseState, boundaryID, contentSegmentID, boundaryResources) {
var hasStyleDependencies;
@@ -4569,62 +4588,84 @@ function writeCompletedBoundaryInstruction(destination, responseState, boundaryI
hasStyleDependencies = hasStyleResourceDependencies(boundaryResources);
}
- writeChunk(destination, responseState.startInlineScript);
-
- if ( hasStyleDependencies) {
- if (!responseState.sentCompleteBoundaryFunction) {
- responseState.sentCompleteBoundaryFunction = true;
- responseState.sentStyleInsertionFunction = true;
- writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
- } else if (!responseState.sentStyleInsertionFunction) {
- responseState.sentStyleInsertionFunction = true;
- writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
- } else {
- writeChunk(destination, completeBoundaryWithStylesScript1Partial);
- }
- } else {
- if (!responseState.sentCompleteBoundaryFunction) {
- responseState.sentCompleteBoundaryFunction = true;
- writeChunk(destination, completeBoundaryScript1Full);
+ {
+ writeChunk(destination, responseState.startInlineScript);
+
+ if ( hasStyleDependencies) {
+ if (!responseState.sentCompleteBoundaryFunction) {
+ responseState.sentCompleteBoundaryFunction = true;
+ responseState.sentStyleInsertionFunction = true;
+ writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+ } else if (!responseState.sentStyleInsertionFunction) {
+ responseState.sentStyleInsertionFunction = true;
+ writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+ } else {
+ writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+ }
} else {
- writeChunk(destination, completeBoundaryScript1Partial);
+ if (!responseState.sentCompleteBoundaryFunction) {
+ responseState.sentCompleteBoundaryFunction = true;
+ writeChunk(destination, completeBoundaryScript1Full);
+ } else {
+ writeChunk(destination, completeBoundaryScript1Partial);
+ }
}
}
if (boundaryID === null) {
throw new Error('An ID must have been assigned before we can complete the boundary.');
- }
+ } // Write function arguments, which are string and array literals
+
var formattedContentID = stringToChunk(contentSegmentID.toString(16));
writeChunk(destination, boundaryID);
- writeChunk(destination, completeBoundaryScript2);
+
+ {
+ writeChunk(destination, completeBoundaryScript2);
+ }
+
writeChunk(destination, responseState.segmentPrefix);
writeChunk(destination, formattedContentID);
if ( hasStyleDependencies) {
- writeChunk(destination, completeBoundaryScript2a);
- writeStyleResourceDependencies(destination, boundaryResources);
+ // Script and data writers must format this differently:
+ // - script writer emits an array literal, whose string elements are
+ // escaped for javascript e.g. ["A", "B"]
+ // - data writer emits a string literal, which is escaped as html
+ // e.g. ["A", "B"]
+ {
+ writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+ writeStyleResourceDependenciesInJS(destination, boundaryResources);
+ }
} else {
- writeChunk(destination, completeBoundaryScript3);
+ {
+ writeChunk(destination, completeBoundaryScript3b);
+ }
}
- return writeChunkAndReturn(destination, completeBoundaryScript4);
+ {
+ return writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+ }
}
var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
var clientRenderScript1A = stringToPrecomputedChunk('"');
-var clientRenderScript2 = stringToPrecomputedChunk(')');
var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+var clientRenderScriptEnd = stringToPrecomputedChunk(')');
function writeClientRenderBoundaryInstruction(destination, responseState, boundaryID, errorDigest, errorMessage, errorComponentStack) {
- writeChunk(destination, responseState.startInlineScript);
- if (!responseState.sentClientRenderFunction) {
- // The first time we write this, we'll need to include the full implementation.
- responseState.sentClientRenderFunction = true;
- writeChunk(destination, clientRenderScript1Full);
- } else {
- // Future calls can just reuse the same function.
- writeChunk(destination, clientRenderScript1Partial);
+ {
+ writeChunk(destination, responseState.startInlineScript);
+
+ if (!responseState.sentClientRenderFunction) {
+ // The first time we write this, we'll need to include the full implementation.
+ responseState.sentClientRenderFunction = true;
+ writeChunk(destination, clientRenderScript1Full);
+ } else {
+ // Future calls can just reuse the same function.
+ writeChunk(destination, clientRenderScript1Partial);
+ }
}
if (boundaryID === null) {
@@ -4632,24 +4673,41 @@ function writeClientRenderBoundaryInstruction(destination, responseState, bounda
}
writeChunk(destination, boundaryID);
- writeChunk(destination, clientRenderScript1A);
+
+ {
+ // " needs to be inserted for scripts, since ArgInterstitual does not contain
+ // leading or trailing quotes
+ writeChunk(destination, clientRenderScript1A);
+ }
if (errorDigest || errorMessage || errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+ {
+ // ,"JSONString"
+ writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+ writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+ }
}
if (errorMessage || errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+ {
+ // ,"JSONString"
+ writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+ writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+ }
}
if (errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+ // ,"JSONString"
+ {
+ writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+ writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+ }
}
- return writeChunkAndReturn(destination, clientRenderScript2);
+ {
+ // >
+ return writeChunkAndReturn(destination, clientRenderScriptEnd);
+ }
}
var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
@@ -4709,7 +4767,8 @@ function escapeJSObjectForInstructionScripts(input) {
var precedencePlaceholderStart = stringToPrecomputedChunk('');
-function writeInitialResources(destination, resources, responseState) {
+function writeInitialResources(destination, resources, responseState, willFlushAllSegments) {
+
function flushLinkResource(resource) {
if (!resource.flushed) {
pushLinkImpl(target, resource.props, responseState);
@@ -4933,20 +4992,22 @@ function hasStyleResourceDependencies(boundaryResources) {
var arrayFirstOpenBracket = stringToPrecomputedChunk('[');
var arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
var arrayInterstitial = stringToPrecomputedChunk(',');
-var arrayCloseBracket = stringToPrecomputedChunk(']');
+var arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+// [["JS_escaped_string1", "JS_escaped_string2"]]
-function writeStyleResourceDependencies(destination, boundaryResources) {
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
writeChunk(destination, arrayFirstOpenBracket);
var nextArrayOpenBrackChunk = arrayFirstOpenBracket;
boundaryResources.forEach(function (resource) {
if (resource.inShell) ; else if (resource.flushed) {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependencyHrefOnly(destination, resource.href);
+ writeStyleResourceDependencyHrefOnlyInJS(destination, resource.href);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
} else {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependency(destination, resource.href, resource.precedence, resource.props);
+ writeStyleResourceDependencyInJS(destination, resource.href, resource.precedence, resource.props);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
resource.flushed = true;
@@ -4955,8 +5016,10 @@ function writeStyleResourceDependencies(destination, boundaryResources) {
});
writeChunk(destination, arrayCloseBracket);
}
+/* Helper functions */
-function writeStyleResourceDependencyHrefOnly(destination, href) {
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
// We should actually enforce this earlier when the resource is created but for
// now we make sure we are actually dealing with a string here.
{
@@ -4967,7 +5030,7 @@ function writeStyleResourceDependencyHrefOnly(destination, href) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
}
-function writeStyleResourceDependency(destination, href, precedence, props) {
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
{
checkAttributeStringCoercion(href, 'href');
}
@@ -5007,7 +5070,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
// eslint-disable-next-line-no-fallthrough
default:
- writeStyleResourceAttribute(destination, propKey, propValue);
+ writeStyleResourceAttributeInJS(destination, propKey, propValue);
break;
}
}
@@ -5016,7 +5079,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
return null;
}
-function writeStyleResourceAttribute(destination, name, value) {
+function writeStyleResourceAttributeInJS(destination, name, value) {
var attributeName = name.toLowerCase();
var attributeValue;
@@ -5086,23 +5149,25 @@ function writeStyleResourceAttribute(destination, name, value) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
writeChunk(destination, arrayInterstitial);
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
-}
+} // This function writes a 2D array of strings to be embedded in an attribute
-function createResponseState$1(generateStaticMarkup, identifierPrefix) {
- var responseState = createResponseState(identifierPrefix, undefined);
+function createResponseState$1(generateStaticMarkup, identifierPrefix, externalRuntimeConfig) {
+ var responseState = createResponseState(identifierPrefix, undefined, undefined, undefined, undefined);
return {
// Keep this in sync with ReactDOMServerFormatConfig
bootstrapChunks: responseState.bootstrapChunks,
- startInlineScript: responseState.startInlineScript,
placeholderPrefix: responseState.placeholderPrefix,
segmentPrefix: responseState.segmentPrefix,
boundaryPrefix: responseState.boundaryPrefix,
idPrefix: responseState.idPrefix,
nextSuspenseID: responseState.nextSuspenseID,
+ streamingFormat: responseState.streamingFormat,
+ startInlineScript: responseState.startInlineScript,
sentCompleteSegmentFunction: responseState.sentCompleteSegmentFunction,
sentCompleteBoundaryFunction: responseState.sentCompleteBoundaryFunction,
sentClientRenderFunction: responseState.sentClientRenderFunction,
sentStyleInsertionFunction: responseState.sentStyleInsertionFunction,
+ externalRuntimeConfig: responseState.externalRuntimeConfig,
// This is an extra field for the legacy renderer
generateStaticMarkup: generateStaticMarkup
};
@@ -8807,7 +8872,7 @@ function flushSegment(request, destination, segment) {
}
}
-function flushInitialResources(destination, resources, responseState) {
+function flushInitialResources(destination, resources, responseState, willFlushAllSegments) {
writeInitialResources(destination, resources, responseState);
}
@@ -8910,7 +8975,7 @@ function flushCompletedQueues(request, destination) {
writeChunk(destination, preamble[i]);
}
- flushInitialResources(destination, request.resources, request.responseState);
+ flushInitialResources(destination, request.resources, request.responseState, request.allPendingTasks === 0);
}
flushSegment(request, destination, completedRootSegment);
@@ -9076,7 +9141,7 @@ function abort(request, reason) {
function onError() {// Non-fatal errors are ignored.
}
-function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
+function renderToStringImpl(children, options, generateStaticMarkup, abortReason, unstable_externalRuntimeSrc) {
var didFatal = false;
var fatalError = null;
var result = '';
diff --git a/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js b/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js
index 894fd2cc613aba3..b110a7000169643 100644
--- a/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js
+++ b/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js
@@ -20,7 +20,7 @@ var ja={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderIma
zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},ka=["Webkit","ms","Moz","O"];Object.keys(ja).forEach(function(a){ka.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);ja[b]=ja[a]})});var la=/["'&<>]/;
function w(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=la.exec(a);if(b){var c="",d,e=0;for(d=b.index;d",placeholderPrefix:b+"P:",segmentPrefix:b+"S:",boundaryPrefix:b+"B:",idPrefix:b,nextSuspenseID:0,sentCompleteSegmentFunction:!1,sentCompleteBoundaryFunction:!1,sentClientRenderFunction:!1,sentStyleInsertionFunction:!1,generateStaticMarkup:a}}function Xa(a,b,c,d){if(c.generateStaticMarkup)return a.push(w(b)),!1;""===b?a=d:(d&&a.push("\x3c!-- --\x3e"),a.push(w(b)),a=!0);return a}
+function Wa(a,b){b=void 0===b?"":b;return{bootstrapChunks:[],placeholderPrefix:b+"P:",segmentPrefix:b+"S:",boundaryPrefix:b+"B:",idPrefix:b,nextSuspenseID:0,streamingFormat:0,startInlineScript:"');
var startScriptSrc = stringToPrecomputedChunk('');
+var completeSegmentScriptEnd = stringToPrecomputedChunk('")');
function writeCompletedSegmentInstruction(destination, responseState, contentSegmentID) {
- writeChunk(destination, responseState.startInlineScript);
- if (!responseState.sentCompleteSegmentFunction) {
- // The first time we write this, we'll need to include the full implementation.
- responseState.sentCompleteSegmentFunction = true;
- writeChunk(destination, completeSegmentScript1Full);
- } else {
- // Future calls can just reuse the same function.
- writeChunk(destination, completeSegmentScript1Partial);
- }
+ {
+ writeChunk(destination, responseState.startInlineScript);
+
+ if (!responseState.sentCompleteSegmentFunction) {
+ // The first time we write this, we'll need to include the full implementation.
+ responseState.sentCompleteSegmentFunction = true;
+ writeChunk(destination, completeSegmentScript1Full);
+ } else {
+ // Future calls can just reuse the same function.
+ writeChunk(destination, completeSegmentScript1Partial);
+ }
+ } // Write function arguments, which are string literals
+
writeChunk(destination, responseState.segmentPrefix);
var formattedID = stringToChunk(contentSegmentID.toString(16));
writeChunk(destination, formattedID);
- writeChunk(destination, completeSegmentScript2);
+
+ {
+ writeChunk(destination, completeSegmentScript2);
+ }
+
writeChunk(destination, responseState.placeholderPrefix);
writeChunk(destination, formattedID);
- return writeChunkAndReturn(destination, completeSegmentScript3);
+
+ {
+ return writeChunkAndReturn(destination, completeSegmentScriptEnd);
+ }
}
var completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + ';$RC("');
var completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
@@ -4560,9 +4579,9 @@ var completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(complet
var completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + ';$RR("');
var completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
var completeBoundaryScript2 = stringToPrecomputedChunk('","');
-var completeBoundaryScript2a = stringToPrecomputedChunk('",');
-var completeBoundaryScript3 = stringToPrecomputedChunk('"');
-var completeBoundaryScript4 = stringToPrecomputedChunk(')');
+var completeBoundaryScript3a = stringToPrecomputedChunk('",');
+var completeBoundaryScript3b = stringToPrecomputedChunk('"');
+var completeBoundaryScriptEnd = stringToPrecomputedChunk(')');
function writeCompletedBoundaryInstruction(destination, responseState, boundaryID, contentSegmentID, boundaryResources) {
var hasStyleDependencies;
@@ -4570,62 +4589,84 @@ function writeCompletedBoundaryInstruction(destination, responseState, boundaryI
hasStyleDependencies = hasStyleResourceDependencies(boundaryResources);
}
- writeChunk(destination, responseState.startInlineScript);
-
- if ( hasStyleDependencies) {
- if (!responseState.sentCompleteBoundaryFunction) {
- responseState.sentCompleteBoundaryFunction = true;
- responseState.sentStyleInsertionFunction = true;
- writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
- } else if (!responseState.sentStyleInsertionFunction) {
- responseState.sentStyleInsertionFunction = true;
- writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
- } else {
- writeChunk(destination, completeBoundaryWithStylesScript1Partial);
- }
- } else {
- if (!responseState.sentCompleteBoundaryFunction) {
- responseState.sentCompleteBoundaryFunction = true;
- writeChunk(destination, completeBoundaryScript1Full);
+ {
+ writeChunk(destination, responseState.startInlineScript);
+
+ if ( hasStyleDependencies) {
+ if (!responseState.sentCompleteBoundaryFunction) {
+ responseState.sentCompleteBoundaryFunction = true;
+ responseState.sentStyleInsertionFunction = true;
+ writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
+ } else if (!responseState.sentStyleInsertionFunction) {
+ responseState.sentStyleInsertionFunction = true;
+ writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
+ } else {
+ writeChunk(destination, completeBoundaryWithStylesScript1Partial);
+ }
} else {
- writeChunk(destination, completeBoundaryScript1Partial);
+ if (!responseState.sentCompleteBoundaryFunction) {
+ responseState.sentCompleteBoundaryFunction = true;
+ writeChunk(destination, completeBoundaryScript1Full);
+ } else {
+ writeChunk(destination, completeBoundaryScript1Partial);
+ }
}
}
if (boundaryID === null) {
throw new Error('An ID must have been assigned before we can complete the boundary.');
- }
+ } // Write function arguments, which are string and array literals
+
var formattedContentID = stringToChunk(contentSegmentID.toString(16));
writeChunk(destination, boundaryID);
- writeChunk(destination, completeBoundaryScript2);
+
+ {
+ writeChunk(destination, completeBoundaryScript2);
+ }
+
writeChunk(destination, responseState.segmentPrefix);
writeChunk(destination, formattedContentID);
if ( hasStyleDependencies) {
- writeChunk(destination, completeBoundaryScript2a);
- writeStyleResourceDependencies(destination, boundaryResources);
+ // Script and data writers must format this differently:
+ // - script writer emits an array literal, whose string elements are
+ // escaped for javascript e.g. ["A", "B"]
+ // - data writer emits a string literal, which is escaped as html
+ // e.g. ["A", "B"]
+ {
+ writeChunk(destination, completeBoundaryScript3a); // boundaryResources encodes an array literal
+
+ writeStyleResourceDependenciesInJS(destination, boundaryResources);
+ }
} else {
- writeChunk(destination, completeBoundaryScript3);
+ {
+ writeChunk(destination, completeBoundaryScript3b);
+ }
}
- return writeChunkAndReturn(destination, completeBoundaryScript4);
+ {
+ return writeChunkAndReturn(destination, completeBoundaryScriptEnd);
+ }
}
var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
var clientRenderScript1A = stringToPrecomputedChunk('"');
-var clientRenderScript2 = stringToPrecomputedChunk(')');
var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+var clientRenderScriptEnd = stringToPrecomputedChunk(')');
function writeClientRenderBoundaryInstruction(destination, responseState, boundaryID, errorDigest, errorMessage, errorComponentStack) {
- writeChunk(destination, responseState.startInlineScript);
- if (!responseState.sentClientRenderFunction) {
- // The first time we write this, we'll need to include the full implementation.
- responseState.sentClientRenderFunction = true;
- writeChunk(destination, clientRenderScript1Full);
- } else {
- // Future calls can just reuse the same function.
- writeChunk(destination, clientRenderScript1Partial);
+ {
+ writeChunk(destination, responseState.startInlineScript);
+
+ if (!responseState.sentClientRenderFunction) {
+ // The first time we write this, we'll need to include the full implementation.
+ responseState.sentClientRenderFunction = true;
+ writeChunk(destination, clientRenderScript1Full);
+ } else {
+ // Future calls can just reuse the same function.
+ writeChunk(destination, clientRenderScript1Partial);
+ }
}
if (boundaryID === null) {
@@ -4633,24 +4674,41 @@ function writeClientRenderBoundaryInstruction(destination, responseState, bounda
}
writeChunk(destination, boundaryID);
- writeChunk(destination, clientRenderScript1A);
+
+ {
+ // " needs to be inserted for scripts, since ArgInterstitual does not contain
+ // leading or trailing quotes
+ writeChunk(destination, clientRenderScript1A);
+ }
if (errorDigest || errorMessage || errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+ {
+ // ,"JSONString"
+ writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+ writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
+ }
}
if (errorMessage || errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+ {
+ // ,"JSONString"
+ writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+ writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
+ }
}
if (errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+ // ,"JSONString"
+ {
+ writeChunk(destination, clientRenderErrorScriptArgInterstitial);
+ writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
+ }
}
- return writeChunkAndReturn(destination, clientRenderScript2);
+ {
+ // >
+ return writeChunkAndReturn(destination, clientRenderScriptEnd);
+ }
}
var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
@@ -4710,7 +4768,8 @@ function escapeJSObjectForInstructionScripts(input) {
var precedencePlaceholderStart = stringToPrecomputedChunk('');
-function writeInitialResources(destination, resources, responseState) {
+function writeInitialResources(destination, resources, responseState, willFlushAllSegments) {
+
function flushLinkResource(resource) {
if (!resource.flushed) {
pushLinkImpl(target, resource.props, responseState);
@@ -4934,20 +4993,22 @@ function hasStyleResourceDependencies(boundaryResources) {
var arrayFirstOpenBracket = stringToPrecomputedChunk('[');
var arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
var arrayInterstitial = stringToPrecomputedChunk(',');
-var arrayCloseBracket = stringToPrecomputedChunk(']');
+var arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+// [["JS_escaped_string1", "JS_escaped_string2"]]
-function writeStyleResourceDependencies(destination, boundaryResources) {
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
writeChunk(destination, arrayFirstOpenBracket);
var nextArrayOpenBrackChunk = arrayFirstOpenBracket;
boundaryResources.forEach(function (resource) {
if (resource.inShell) ; else if (resource.flushed) {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependencyHrefOnly(destination, resource.href);
+ writeStyleResourceDependencyHrefOnlyInJS(destination, resource.href);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
} else {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependency(destination, resource.href, resource.precedence, resource.props);
+ writeStyleResourceDependencyInJS(destination, resource.href, resource.precedence, resource.props);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
resource.flushed = true;
@@ -4956,8 +5017,10 @@ function writeStyleResourceDependencies(destination, boundaryResources) {
});
writeChunk(destination, arrayCloseBracket);
}
+/* Helper functions */
-function writeStyleResourceDependencyHrefOnly(destination, href) {
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
// We should actually enforce this earlier when the resource is created but for
// now we make sure we are actually dealing with a string here.
{
@@ -4968,7 +5031,7 @@ function writeStyleResourceDependencyHrefOnly(destination, href) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
}
-function writeStyleResourceDependency(destination, href, precedence, props) {
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
{
checkAttributeStringCoercion(href, 'href');
}
@@ -5008,7 +5071,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
// eslint-disable-next-line-no-fallthrough
default:
- writeStyleResourceAttribute(destination, propKey, propValue);
+ writeStyleResourceAttributeInJS(destination, propKey, propValue);
break;
}
}
@@ -5017,7 +5080,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
return null;
}
-function writeStyleResourceAttribute(destination, name, value) {
+function writeStyleResourceAttributeInJS(destination, name, value) {
var attributeName = name.toLowerCase();
var attributeValue;
@@ -5087,23 +5150,25 @@ function writeStyleResourceAttribute(destination, name, value) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
writeChunk(destination, arrayInterstitial);
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
-}
+} // This function writes a 2D array of strings to be embedded in an attribute
-function createResponseState$1(generateStaticMarkup, identifierPrefix) {
- var responseState = createResponseState(identifierPrefix, undefined);
+function createResponseState$1(generateStaticMarkup, identifierPrefix, externalRuntimeConfig) {
+ var responseState = createResponseState(identifierPrefix, undefined, undefined, undefined, undefined);
return {
// Keep this in sync with ReactDOMServerFormatConfig
bootstrapChunks: responseState.bootstrapChunks,
- startInlineScript: responseState.startInlineScript,
placeholderPrefix: responseState.placeholderPrefix,
segmentPrefix: responseState.segmentPrefix,
boundaryPrefix: responseState.boundaryPrefix,
idPrefix: responseState.idPrefix,
nextSuspenseID: responseState.nextSuspenseID,
+ streamingFormat: responseState.streamingFormat,
+ startInlineScript: responseState.startInlineScript,
sentCompleteSegmentFunction: responseState.sentCompleteSegmentFunction,
sentCompleteBoundaryFunction: responseState.sentCompleteBoundaryFunction,
sentClientRenderFunction: responseState.sentClientRenderFunction,
sentStyleInsertionFunction: responseState.sentStyleInsertionFunction,
+ externalRuntimeConfig: responseState.externalRuntimeConfig,
// This is an extra field for the legacy renderer
generateStaticMarkup: generateStaticMarkup
};
@@ -8808,7 +8873,7 @@ function flushSegment(request, destination, segment) {
}
}
-function flushInitialResources(destination, resources, responseState) {
+function flushInitialResources(destination, resources, responseState, willFlushAllSegments) {
writeInitialResources(destination, resources, responseState);
}
@@ -8911,7 +8976,7 @@ function flushCompletedQueues(request, destination) {
writeChunk(destination, preamble[i]);
}
- flushInitialResources(destination, request.resources, request.responseState);
+ flushInitialResources(destination, request.resources, request.responseState, request.allPendingTasks === 0);
}
flushSegment(request, destination, completedRootSegment);
@@ -9077,7 +9142,7 @@ function abort(request, reason) {
function onError() {// Non-fatal errors are ignored.
}
-function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
+function renderToStringImpl(children, options, generateStaticMarkup, abortReason, unstable_externalRuntimeSrc) {
var didFatal = false;
var fatalError = null;
var result = '';
diff --git a/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js b/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js
index 0ed31409502a891..dc06fa715e846a1 100644
--- a/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js
+++ b/packages/next/compiled/react-dom/cjs/react-dom-server-legacy.node.production.min.js
@@ -19,7 +19,7 @@ var ka={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderIma
zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},la=["Webkit","ms","Moz","O"];Object.keys(ka).forEach(function(a){la.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);ka[b]=ka[a]})});var ma=/["'&<>]/;
function v(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=ma.exec(a);if(b){var c="",d,e=0;for(d=b.index;d",placeholderPrefix:b+"P:",segmentPrefix:b+"S:",boundaryPrefix:b+"B:",idPrefix:b,nextSuspenseID:0,sentCompleteSegmentFunction:!1,sentCompleteBoundaryFunction:!1,sentClientRenderFunction:!1,sentStyleInsertionFunction:!1,generateStaticMarkup:a}}function Ya(){return{insertionMode:1,selectedValue:null,noscriptTagInScope:!1}}
-function Za(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}
+c=",[";b.flushed=!0;b.hint.flushed=!0}});a.push("]")}function Xa(a,b){b=void 0===b?"":b;return{bootstrapChunks:[],placeholderPrefix:b+"P:",segmentPrefix:b+"S:",boundaryPrefix:b+"B:",idPrefix:b,nextSuspenseID:0,streamingFormat:0,startInlineScript:"');
var startScriptSrc = stringToPrecomputedChunk('');
+var completeSegmentScriptEnd = stringToPrecomputedChunk('")');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryScript3a = stringToPrecomputedChunk('",');
+var completeBoundaryScript3b = stringToPrecomputedChunk('"');
+var completeBoundaryScriptEnd = stringToPrecomputedChunk(')');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+var clientRenderScriptEnd = stringToPrecomputedChunk(')');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderScriptEnd);
+ }
}
var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
@@ -4798,7 +4868,8 @@ function escapeJSObjectForInstructionScripts(input) {
var precedencePlaceholderStart = stringToPrecomputedChunk('');
-function writeInitialResources(destination, resources, responseState) {
+function writeInitialResources(destination, resources, responseState, willFlushAllSegments) {
+
function flushLinkResource(resource) {
if (!resource.flushed) {
pushLinkImpl(target, resource.props, responseState);
@@ -5022,20 +5093,22 @@ function hasStyleResourceDependencies(boundaryResources) {
var arrayFirstOpenBracket = stringToPrecomputedChunk('[');
var arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
var arrayInterstitial = stringToPrecomputedChunk(',');
-var arrayCloseBracket = stringToPrecomputedChunk(']');
+var arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+// [["JS_escaped_string1", "JS_escaped_string2"]]
-function writeStyleResourceDependencies(destination, boundaryResources) {
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
writeChunk(destination, arrayFirstOpenBracket);
var nextArrayOpenBrackChunk = arrayFirstOpenBracket;
boundaryResources.forEach(function (resource) {
if (resource.inShell) ; else if (resource.flushed) {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependencyHrefOnly(destination, resource.href);
+ writeStyleResourceDependencyHrefOnlyInJS(destination, resource.href);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
} else {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependency(destination, resource.href, resource.precedence, resource.props);
+ writeStyleResourceDependencyInJS(destination, resource.href, resource.precedence, resource.props);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
resource.flushed = true;
@@ -5044,8 +5117,10 @@ function writeStyleResourceDependencies(destination, boundaryResources) {
});
writeChunk(destination, arrayCloseBracket);
}
+/* Helper functions */
-function writeStyleResourceDependencyHrefOnly(destination, href) {
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
// We should actually enforce this earlier when the resource is created but for
// now we make sure we are actually dealing with a string here.
{
@@ -5056,7 +5131,7 @@ function writeStyleResourceDependencyHrefOnly(destination, href) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
}
-function writeStyleResourceDependency(destination, href, precedence, props) {
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
{
checkAttributeStringCoercion(href, 'href');
}
@@ -5096,7 +5171,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
// eslint-disable-next-line-no-fallthrough
default:
- writeStyleResourceAttribute(destination, propKey, propValue);
+ writeStyleResourceAttributeInJS(destination, propKey, propValue);
break;
}
}
@@ -5105,7 +5180,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
return null;
}
-function writeStyleResourceAttribute(destination, name, value) {
+function writeStyleResourceAttributeInJS(destination, name, value) {
var attributeName = name.toLowerCase();
var attributeValue;
@@ -5175,7 +5250,7 @@ function writeStyleResourceAttribute(destination, name, value) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
writeChunk(destination, arrayInterstitial);
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
-}
+} // This function writes a 2D array of strings to be embedded in an attribute
// ATTENTION
// When adding new symbols to this file,
@@ -8820,7 +8895,7 @@ function flushSegment(request, destination, segment) {
}
}
-function flushInitialResources(destination, resources, responseState) {
+function flushInitialResources(destination, resources, responseState, willFlushAllSegments) {
writeInitialResources(destination, resources, responseState);
}
@@ -8924,7 +8999,7 @@ function flushCompletedQueues(request, destination) {
writeChunk(destination, preamble[i]);
}
- flushInitialResources(destination, request.resources, request.responseState);
+ flushInitialResources(destination, request.resources, request.responseState, request.allPendingTasks === 0);
}
flushSegment(request, destination, completedRootSegment);
diff --git a/packages/next/compiled/react-dom/cjs/react-dom-server.browser.production.min.js b/packages/next/compiled/react-dom/cjs/react-dom-server.browser.production.min.js
index 41f10c15b01cde2..cab60f46d2522b0 100644
--- a/packages/next/compiled/react-dom/cjs/react-dom-server.browser.production.min.js
+++ b/packages/next/compiled/react-dom/cjs/react-dom-server.browser.production.min.js
@@ -21,7 +21,7 @@ var pa={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderIma
zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},qa=["Webkit","ms","Moz","O"];Object.keys(pa).forEach(function(a){qa.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);pa[b]=pa[a]})});var ra=/["'&<>]/;
function C(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=ra.exec(a);if(b){var c="",d,e=0;for(d=b.index;d"),Ja=x("\x3c/script>"),Ka=x('');
-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 ');
-function writeCompletedSegmentInstruction(destination, responseState, contentSegmentID) {
- writeChunk(destination, responseState.startInlineScript);
-
- if (!responseState.sentCompleteSegmentFunction) {
- // The first time we write this, we'll need to include the full implementation.
- responseState.sentCompleteSegmentFunction = true;
- writeChunk(destination, completeSegmentScript1Full);
- } else {
- // Future calls can just reuse the same function.
- writeChunk(destination, completeSegmentScript1Partial);
- }
-
- writeChunk(destination, responseState.segmentPrefix);
- var formattedID = stringToChunk(contentSegmentID.toString(16));
- writeChunk(destination, formattedID);
- writeChunk(destination, completeSegmentScript2);
- writeChunk(destination, responseState.placeholderPrefix);
- writeChunk(destination, formattedID);
- return writeChunkAndReturn(destination, completeSegmentScript3);
-}
-var completeBoundaryScript1Full = stringToPrecomputedChunk(completeBoundary + ';$RC("');
-var completeBoundaryScript1Partial = stringToPrecomputedChunk('$RC("');
-var completeBoundaryWithStylesScript1FullBoth = stringToPrecomputedChunk(completeBoundary + ';' + completeBoundaryWithStyles + ';$RR("');
-var completeBoundaryWithStylesScript1FullPartial = stringToPrecomputedChunk(completeBoundaryWithStyles + ';$RR("');
-var completeBoundaryWithStylesScript1Partial = stringToPrecomputedChunk('$RR("');
-var completeBoundaryScript2 = stringToPrecomputedChunk('","');
-var completeBoundaryScript2a = stringToPrecomputedChunk('",');
-var completeBoundaryScript3 = stringToPrecomputedChunk('"');
-var completeBoundaryScript4 = stringToPrecomputedChunk(')');
-function writeCompletedBoundaryInstruction(destination, responseState, boundaryID, contentSegmentID, boundaryResources) {
- var hasStyleDependencies;
-
- {
- hasStyleDependencies = hasStyleResourceDependencies(boundaryResources);
- }
-
- writeChunk(destination, responseState.startInlineScript);
-
- if ( hasStyleDependencies) {
- if (!responseState.sentCompleteBoundaryFunction) {
- responseState.sentCompleteBoundaryFunction = true;
- responseState.sentStyleInsertionFunction = true;
- writeChunk(destination, clonePrecomputedChunk(completeBoundaryWithStylesScript1FullBoth));
- } else if (!responseState.sentStyleInsertionFunction) {
- responseState.sentStyleInsertionFunction = true;
- writeChunk(destination, completeBoundaryWithStylesScript1FullPartial);
- } else {
- writeChunk(destination, completeBoundaryWithStylesScript1Partial);
- }
- } else {
- if (!responseState.sentCompleteBoundaryFunction) {
- responseState.sentCompleteBoundaryFunction = true;
- writeChunk(destination, completeBoundaryScript1Full);
- } else {
- writeChunk(destination, completeBoundaryScript1Partial);
- }
- }
-
- if (boundaryID === null) {
- throw new Error('An ID must have been assigned before we can complete the boundary.');
- }
-
- var formattedContentID = stringToChunk(contentSegmentID.toString(16));
- writeChunk(destination, boundaryID);
- writeChunk(destination, completeBoundaryScript2);
- writeChunk(destination, responseState.segmentPrefix);
- writeChunk(destination, formattedContentID);
-
- if ( hasStyleDependencies) {
- writeChunk(destination, completeBoundaryScript2a);
- writeStyleResourceDependencies(destination, boundaryResources);
- } else {
- writeChunk(destination, completeBoundaryScript3);
- }
-
- return writeChunkAndReturn(destination, completeBoundaryScript4);
-}
-var clientRenderScript1Full = stringToPrecomputedChunk(clientRenderBoundary + ';$RX("');
-var clientRenderScript1Partial = stringToPrecomputedChunk('$RX("');
-var clientRenderScript1A = stringToPrecomputedChunk('"');
-var clientRenderScript2 = stringToPrecomputedChunk(')');
-var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
-function writeClientRenderBoundaryInstruction(destination, responseState, boundaryID, errorDigest, errorMessage, errorComponentStack) {
- writeChunk(destination, responseState.startInlineScript);
-
- if (!responseState.sentClientRenderFunction) {
- // The first time we write this, we'll need to include the full implementation.
- responseState.sentClientRenderFunction = true;
- writeChunk(destination, clientRenderScript1Full);
- } else {
- // Future calls can just reuse the same function.
- writeChunk(destination, clientRenderScript1Partial);
- }
-
- if (boundaryID === null) {
- throw new Error('An ID must have been assigned before we can complete the boundary.');
- }
-
- writeChunk(destination, boundaryID);
- writeChunk(destination, clientRenderScript1A);
-
- if (errorDigest || errorMessage || errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorDigest || '')));
- }
-
- if (errorMessage || errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorMessage || '')));
- }
-
- if (errorComponentStack) {
- writeChunk(destination, clientRenderErrorScriptArgInterstitial);
- writeChunk(destination, stringToChunk(escapeJSStringsForInstructionScripts(errorComponentStack)));
- }
-
- return writeChunkAndReturn(destination, clientRenderScript2);
-}
-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 precedencePlaceholderStart = stringToPrecomputedChunk('');
-function writeInitialResources(destination, resources, responseState) {
- function flushLinkResource(resource) {
- if (!resource.flushed) {
- pushLinkImpl(target, resource.props, responseState);
- resource.flushed = true;
- }
- }
-
- var target = [];
- var charset = resources.charset,
- bases = resources.bases,
- preconnects = resources.preconnects,
- fontPreloads = resources.fontPreloads,
- precedences = resources.precedences,
- usedStylePreloads = resources.usedStylePreloads,
- scripts = resources.scripts,
- usedScriptPreloads = resources.usedScriptPreloads,
- explicitStylePreloads = resources.explicitStylePreloads,
- explicitScriptPreloads = resources.explicitScriptPreloads,
- headResources = resources.headResources;
-
- if (charset) {
- pushSelfClosing(target, charset.props, 'meta', responseState);
- charset.flushed = true;
- resources.charset = null;
- }
-
- bases.forEach(function (r) {
- pushSelfClosing(target, r.props, 'base', responseState);
- r.flushed = true;
- });
- bases.clear();
- preconnects.forEach(function (r) {
- // font preload Resources should not already be flushed so we elide this check
- pushLinkImpl(target, r.props, responseState);
- r.flushed = true;
- });
- preconnects.clear();
- fontPreloads.forEach(function (r) {
- // font preload Resources should not already be flushed so we elide this check
- pushLinkImpl(target, r.props, responseState);
- r.flushed = true;
- });
- fontPreloads.clear(); // Flush stylesheets first by earliest precedence
-
- precedences.forEach(function (p, precedence) {
- if (p.size) {
- p.forEach(function (r) {
- // resources should not already be flushed so we elide this check
- pushLinkImpl(target, r.props, responseState);
- r.flushed = true;
- r.inShell = true;
- r.hint.flushed = true;
- });
- p.clear();
- } else {
- target.push(precedencePlaceholderStart, stringToChunk(escapeTextForBrowser(precedence)), precedencePlaceholderEnd);
- }
- });
- usedStylePreloads.forEach(flushLinkResource);
- usedStylePreloads.clear();
- scripts.forEach(function (r) {
- // should never be flushed already
- pushScriptImpl(target, r.props, responseState);
- r.flushed = true;
- r.hint.flushed = true;
- });
- scripts.clear();
- usedScriptPreloads.forEach(flushLinkResource);
- usedScriptPreloads.clear();
- explicitStylePreloads.forEach(flushLinkResource);
- explicitStylePreloads.clear();
- explicitScriptPreloads.forEach(flushLinkResource);
- explicitScriptPreloads.clear();
- headResources.forEach(function (r) {
- switch (r.type) {
- case 'title':
- {
- pushTitleImpl(target, r.props, responseState);
- break;
- }
-
- case 'meta':
- {
- pushSelfClosing(target, r.props, 'meta', responseState);
- break;
- }
-
- case 'link':
- {
- pushLinkImpl(target, r.props, responseState);
- break;
- }
- }
-
- r.flushed = true;
- });
- headResources.clear();
- var i;
- var r = true;
-
- for (i = 0; i < target.length - 1; i++) {
- writeChunk(destination, target[i]);
- }
-
- if (i < target.length) {
- r = writeChunkAndReturn(destination, target[i]);
- }
-
- return r;
-}
-function writeImmediateResources(destination, resources, responseState) {
- function flushLinkResource(resource) {
- if (!resource.flushed) {
- pushLinkImpl(target, resource.props, responseState);
- resource.flushed = true;
- }
- }
-
- var target = [];
- var charset = resources.charset,
- preconnects = resources.preconnects,
- fontPreloads = resources.fontPreloads,
- usedStylePreloads = resources.usedStylePreloads,
- scripts = resources.scripts,
- usedScriptPreloads = resources.usedScriptPreloads,
- explicitStylePreloads = resources.explicitStylePreloads,
- explicitScriptPreloads = resources.explicitScriptPreloads,
- headResources = resources.headResources;
-
- if (charset) {
- pushSelfClosing(target, charset.props, 'meta', responseState);
- charset.flushed = true;
- resources.charset = null;
- }
-
- preconnects.forEach(function (r) {
- // font preload Resources should not already be flushed so we elide this check
- pushLinkImpl(target, r.props, responseState);
- r.flushed = true;
- });
- preconnects.clear();
- fontPreloads.forEach(function (r) {
- // font preload Resources should not already be flushed so we elide this check
- pushLinkImpl(target, r.props, responseState);
- r.flushed = true;
- });
- fontPreloads.clear();
- usedStylePreloads.forEach(flushLinkResource);
- usedStylePreloads.clear();
- scripts.forEach(function (r) {
- // should never be flushed already
- pushStartGenericElement(target, r.props, 'script', responseState);
- pushEndInstance(target, target, 'script', r.props);
- r.flushed = true;
- r.hint.flushed = true;
- });
- scripts.clear();
- usedScriptPreloads.forEach(flushLinkResource);
- usedScriptPreloads.clear();
- explicitStylePreloads.forEach(flushLinkResource);
- explicitStylePreloads.clear();
- explicitScriptPreloads.forEach(flushLinkResource);
- explicitScriptPreloads.clear();
- headResources.forEach(function (r) {
- switch (r.type) {
- case 'title':
- {
- pushTitleImpl(target, r.props, responseState);
- break;
- }
-
- case 'meta':
- {
- pushSelfClosing(target, r.props, 'meta', responseState);
- break;
- }
-
- case 'link':
- {
- pushLinkImpl(target, r.props, responseState);
- break;
- }
- }
-
- r.flushed = true;
- });
- headResources.clear();
- var i;
- var r = true;
-
- for (i = 0; i < target.length - 1; i++) {
- writeChunk(destination, target[i]);
- }
-
- if (i < target.length) {
- r = writeChunkAndReturn(destination, target[i]);
- }
-
- return r;
-}
-
-function hasStyleResourceDependencies(boundaryResources) {
- var iter = boundaryResources.values(); // At the moment boundaries only accumulate style resources
- // so we assume the type is correct and don't check it
-
- while (true) {
- var _iter$next = iter.next(),
- resource = _iter$next.value;
-
- if (!resource) break; // If every style Resource flushed in the shell we do not need to send
- // any dependencies
-
- if (!resource.inShell) {
- return true;
- }
- }
-
- return false;
-}
-
-var arrayFirstOpenBracket = stringToPrecomputedChunk('[');
-var arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
-var arrayInterstitial = stringToPrecomputedChunk(',');
-var arrayCloseBracket = stringToPrecomputedChunk(']');
-
-function writeStyleResourceDependencies(destination, boundaryResources) {
- writeChunk(destination, arrayFirstOpenBracket);
- var nextArrayOpenBrackChunk = arrayFirstOpenBracket;
- boundaryResources.forEach(function (resource) {
- if (resource.inShell) ; else if (resource.flushed) {
- writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependencyHrefOnly(destination, resource.href);
- writeChunk(destination, arrayCloseBracket);
- nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
- } else {
- writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependency(destination, resource.href, resource.precedence, resource.props);
- writeChunk(destination, arrayCloseBracket);
- nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
- resource.flushed = true;
- resource.hint.flushed = true;
- }
- });
- writeChunk(destination, arrayCloseBracket);
-}
-
-function writeStyleResourceDependencyHrefOnly(destination, href) {
- // We should actually enforce this earlier when the resource is created but for
- // now we make sure we are actually dealing with a string here.
- {
- checkAttributeStringCoercion(href, 'href');
- }
-
- var coercedHref = '' + href;
- writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
-}
-
-function writeStyleResourceDependency(destination, href, precedence, props) {
- {
- checkAttributeStringCoercion(href, 'href');
- }
-
- var coercedHref = '' + href;
- sanitizeURL(coercedHref);
- writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
-
- {
- checkAttributeStringCoercion(precedence, 'precedence');
- }
-
- var coercedPrecedence = '' + precedence;
- writeChunk(destination, arrayInterstitial);
- writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedPrecedence)));
-
- for (var propKey in props) {
- if (hasOwnProperty.call(props, propKey)) {
- var propValue = props[propKey];
-
- if (propValue == null) {
- continue;
- }
-
- switch (propKey) {
- case 'href':
- case 'rel':
- case 'precedence':
- case 'data-precedence':
- {
- break;
- }
-
- case 'children':
- case 'dangerouslySetInnerHTML':
- throw new Error('link' + " is a self-closing tag and must neither have `children` nor " + 'use `dangerouslySetInnerHTML`.');
- // eslint-disable-next-line-no-fallthrough
-
- default:
- writeStyleResourceAttribute(destination, propKey, propValue);
- break;
- }
- }
- }
-
- return null;
-}
-
-function writeStyleResourceAttribute(destination, name, value) {
- var attributeName = name.toLowerCase();
- var attributeValue;
-
- switch (typeof value) {
- case 'function':
- case 'symbol':
- return;
- }
-
- switch (name) {
- // Reserved names
- case 'innerHTML':
- case 'dangerouslySetInnerHTML':
- case 'suppressContentEditableWarning':
- case 'suppressHydrationWarning':
- case 'style':
- // Ignored
- return;
- // Attribute renames
-
- case 'className':
- attributeName = 'class';
- break;
- // Booleans
-
- case 'hidden':
- if (value === false) {
- return;
- }
-
- attributeValue = '';
- break;
- // Santized URLs
-
- case 'src':
- case 'href':
- {
- {
- checkAttributeStringCoercion(value, attributeName);
- }
-
- attributeValue = '' + value;
- sanitizeURL(attributeValue);
- break;
- }
-
- default:
- {
- if (!isAttributeNameSafe(name)) {
- return;
- }
- }
- }
-
- if ( // shouldIgnoreAttribute
- // We have already filtered out null/undefined and reserved words.
- name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
- return;
- }
-
- {
- checkAttributeStringCoercion(value, attributeName);
- }
-
- attributeValue = '' + value;
- writeChunk(destination, arrayInterstitial);
- writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
- writeChunk(destination, arrayInterstitial);
- writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
-}
-
-// 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_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
-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;
-}
-
-function getWrappedName(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(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(context) + '.Consumer';
-
- case REACT_PROVIDER_TYPE:
- var provider = type;
- return getContextName(provider._context) + '.Provider';
-
- case REACT_FORWARD_REF_TYPE:
- return getWrappedName(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';
- }
-
- // eslint-disable-next-line no-fallthrough
- }
- }
-
- return null;
-}
-
-// 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 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 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 ReactCurrentDispatcher = 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 = typeof WeakMap === 'function' ? WeakMap : Map;
- componentFrameCache = new PossiblyWeakMap();
-}
-
-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 It does accept undefined.
-
- Error.prepareStackTrace = undefined;
- var previousDispatcher;
-
- {
- previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
- // for warnings.
-
- ReactCurrentDispatcher.current = null;
- disableLogs();
- }
-
- try {
- // This should throw.
- if (construct) {
- // Something should be setting the props in the constructor.
- var Fake = function () {
- throw Error();
- }; // $FlowFixMe
-
-
- 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.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(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(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 '';
-}
-
-var loggedTypeFailures = {};
-var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-
-function setCurrentlyValidatingElement(element) {
- {
- if (element) {
- var owner = element._owner;
- var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
- ReactDebugCurrentFrame.setExtraStackFrame(stack);
- } else {
- ReactDebugCurrentFrame.setExtraStackFrame(null);
- }
- }
-}
-
-function checkPropTypes(typeSpecs, values, location, componentName, element) {
- {
- // $FlowFixMe This is okay but Flow doesn't know it.
- var has = Function.call.bind(hasOwnProperty);
-
- for (var typeSpecName in typeSpecs) {
- if (has(typeSpecs, typeSpecName)) {
- var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
- // fail the render phase where it didn't fail before. So we log it.
- // After these have been cleaned up, we'll let them throw.
-
- try {
- // This is intentionally an invariant that gets caught. It's the same
- // behavior as without this statement except with a better message.
- if (typeof typeSpecs[typeSpecName] !== 'function') {
- // eslint-disable-next-line react-internal/prod-error-codes
- var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
- err.name = 'Invariant Violation';
- throw err;
- }
-
- error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
- } catch (ex) {
- error$1 = ex;
- }
-
- if (error$1 && !(error$1 instanceof Error)) {
- setCurrentlyValidatingElement(element);
-
- error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
-
- setCurrentlyValidatingElement(null);
- }
-
- if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
- // Only monitor this failure once because there tends to be a lot of the
- // same error.
- loggedTypeFailures[error$1.message] = true;
- setCurrentlyValidatingElement(element);
-
- error('Failed %s type: %s', location, error$1.message);
-
- setCurrentlyValidatingElement(null);
- }
- }
- }
- }
-}
-
-var warnedAboutMissingGetChildContext;
-
-{
- warnedAboutMissingGetChildContext = {};
-} // $FlowFixMe[incompatible-exact]
-
-
-var emptyContextObject = {};
-
-{
- Object.freeze(emptyContextObject);
-}
-
-function getMaskedContext(type, unmaskedContext) {
- {
- var contextTypes = type.contextTypes;
-
- if (!contextTypes) {
- return emptyContextObject;
- }
-
- var context = {};
-
- for (var key in contextTypes) {
- context[key] = unmaskedContext[key];
- }
-
- {
- var name = getComponentNameFromType(type) || 'Unknown';
- checkPropTypes(contextTypes, context, 'context', name);
- }
-
- return context;
- }
-}
-function processChildContext(instance, type, parentContext, childContextTypes) {
- {
- // TODO (bvaughn) Replace this behavior with an invariant() in the future.
- // It has only been added in Fiber to match the (unintentional) behavior in Stack.
- if (typeof instance.getChildContext !== 'function') {
- {
- var componentName = getComponentNameFromType(type) || 'Unknown';
-
- if (!warnedAboutMissingGetChildContext[componentName]) {
- warnedAboutMissingGetChildContext[componentName] = true;
-
- error('%s.childContextTypes is specified but there is no getChildContext() method ' + 'on the instance. You can either define getChildContext() on %s or remove ' + 'childContextTypes from it.', componentName, componentName);
- }
- }
-
- return parentContext;
- }
-
- var childContext = instance.getChildContext();
-
- for (var contextKey in childContext) {
- if (!(contextKey in childContextTypes)) {
- throw new Error((getComponentNameFromType(type) || 'Unknown') + ".getChildContext(): key \"" + contextKey + "\" is not defined in childContextTypes.");
- }
- }
-
- {
- var name = getComponentNameFromType(type) || 'Unknown';
- checkPropTypes(childContextTypes, childContext, 'child context', name);
- }
-
- return assign({}, parentContext, childContext);
- }
-}
-
-var rendererSigil;
-
-{
- // Use this to detect multiple renderers using the same context
- rendererSigil = {};
-} // Used to store the parent path of all context overrides in a shared linked list.
-// Forming a reverse tree.
-
-
-var rootContextSnapshot = null; // We assume that this runtime owns the "current" field on all ReactContext instances.
-// This global (actually thread local) state represents what state all those "current",
-// fields are currently in.
-
-var currentActiveSnapshot = null;
-
-function popNode(prev) {
- {
- prev.context._currentValue = prev.parentValue;
- }
-}
-
-function pushNode(next) {
- {
- next.context._currentValue = next.value;
- }
-}
-
-function popToNearestCommonAncestor(prev, next) {
- if (prev === next) ; else {
- popNode(prev);
- var parentPrev = prev.parent;
- var parentNext = next.parent;
-
- if (parentPrev === null) {
- if (parentNext !== null) {
- throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
- }
- } else {
- if (parentNext === null) {
- throw new Error('The stacks must reach the root at the same time. This is a bug in React.');
- }
-
- popToNearestCommonAncestor(parentPrev, parentNext);
- } // On the way back, we push the new ones that weren't common.
-
-
- pushNode(next);
- }
-}
-
-function popAllPrevious(prev) {
- popNode(prev);
- var parentPrev = prev.parent;
-
- if (parentPrev !== null) {
- popAllPrevious(parentPrev);
- }
-}
-
-function pushAllNext(next) {
- var parentNext = next.parent;
-
- if (parentNext !== null) {
- pushAllNext(parentNext);
- }
-
- pushNode(next);
-}
-
-function popPreviousToCommonLevel(prev, next) {
- popNode(prev);
- var parentPrev = prev.parent;
-
- if (parentPrev === null) {
- throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
- }
-
- if (parentPrev.depth === next.depth) {
- // We found the same level. Now we just need to find a shared ancestor.
- popToNearestCommonAncestor(parentPrev, next);
- } else {
- // We must still be deeper.
- popPreviousToCommonLevel(parentPrev, next);
- }
-}
-
-function popNextToCommonLevel(prev, next) {
- var parentNext = next.parent;
-
- if (parentNext === null) {
- throw new Error('The depth must equal at least at zero before reaching the root. This is a bug in React.');
- }
-
- if (prev.depth === parentNext.depth) {
- // We found the same level. Now we just need to find a shared ancestor.
- popToNearestCommonAncestor(prev, parentNext);
- } else {
- // We must still be deeper.
- popNextToCommonLevel(prev, parentNext);
- }
-
- pushNode(next);
-} // Perform context switching to the new snapshot.
-// To make it cheap to read many contexts, while not suspending, we make the switch eagerly by
-// updating all the context's current values. That way reads, always just read the current value.
-// At the cost of updating contexts even if they're never read by this subtree.
-
-
-function switchContext(newSnapshot) {
- // The basic algorithm we need to do is to pop back any contexts that are no longer on the stack.
- // We also need to update any new contexts that are now on the stack with the deepest value.
- // The easiest way to update new contexts is to just reapply them in reverse order from the
- // perspective of the backpointers. To avoid allocating a lot when switching, we use the stack
- // for that. Therefore this algorithm is recursive.
- // 1) First we pop which ever snapshot tree was deepest. Popping old contexts as we go.
- // 2) Then we find the nearest common ancestor from there. Popping old contexts as we go.
- // 3) Then we reapply new contexts on the way back up the stack.
- var prev = currentActiveSnapshot;
- var next = newSnapshot;
-
- if (prev !== next) {
- if (prev === null) {
- // $FlowFixMe: This has to be non-null since it's not equal to prev.
- pushAllNext(next);
- } else if (next === null) {
- popAllPrevious(prev);
- } else if (prev.depth === next.depth) {
- popToNearestCommonAncestor(prev, next);
- } else if (prev.depth > next.depth) {
- popPreviousToCommonLevel(prev, next);
- } else {
- popNextToCommonLevel(prev, next);
- }
-
- currentActiveSnapshot = next;
- }
-}
-function pushProvider(context, nextValue) {
- var prevValue;
-
- {
- prevValue = context._currentValue;
- context._currentValue = nextValue;
-
- {
- if (context._currentRenderer !== undefined && context._currentRenderer !== null && context._currentRenderer !== rendererSigil) {
- error('Detected multiple renderers concurrently rendering the ' + 'same context provider. This is currently unsupported.');
- }
-
- context._currentRenderer = rendererSigil;
- }
- }
-
- var prevNode = currentActiveSnapshot;
- var newNode = {
- parent: prevNode,
- depth: prevNode === null ? 0 : prevNode.depth + 1,
- context: context,
- parentValue: prevValue,
- value: nextValue
- };
- currentActiveSnapshot = newNode;
- return newNode;
-}
-function popProvider(context) {
- var prevSnapshot = currentActiveSnapshot;
-
- if (prevSnapshot === null) {
- throw new Error('Tried to pop a Context at the root of the app. This is a bug in React.');
- }
-
- {
- if (prevSnapshot.context !== context) {
- error('The parent context is not the expected context. This is probably a bug in React.');
- }
- }
-
- {
- var value = prevSnapshot.parentValue;
-
- if (value === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
- prevSnapshot.context._currentValue = prevSnapshot.context._defaultValue;
- } else {
- prevSnapshot.context._currentValue = value;
- }
-
- {
- if (context._currentRenderer !== undefined && context._currentRenderer !== null && context._currentRenderer !== rendererSigil) {
- error('Detected multiple renderers concurrently rendering the ' + 'same context provider. This is currently unsupported.');
- }
-
- context._currentRenderer = rendererSigil;
- }
- }
-
- return currentActiveSnapshot = prevSnapshot.parent;
-}
-function getActiveContext() {
- return currentActiveSnapshot;
-}
-function readContext(context) {
- var value = context._currentValue ;
- return value;
-}
-
-/**
- * `ReactInstanceMap` maintains a mapping from a public facing stateful
- * instance (key) and the internal representation (value). This allows public
- * methods to accept the user facing instance as an argument and map them back
- * to internal methods.
- *
- * Note that this module is currently shared and assumed to be stateless.
- * If this becomes an actual Map, that will break.
- */
-function get(key) {
- return key._reactInternals;
-}
-function set(key, value) {
- key._reactInternals = value;
-}
-
-var didWarnAboutNoopUpdateForComponent = {};
-var didWarnAboutDeprecatedWillMount = {};
-var didWarnAboutUninitializedState;
-var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
-var didWarnAboutLegacyLifecyclesAndDerivedState;
-var didWarnAboutUndefinedDerivedState;
-var warnOnUndefinedDerivedState;
-var warnOnInvalidCallback;
-var didWarnAboutDirectlyAssigningPropsToState;
-var didWarnAboutContextTypeAndContextTypes;
-var didWarnAboutInvalidateContextType;
-
-{
- didWarnAboutUninitializedState = new Set();
- didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
- didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
- didWarnAboutDirectlyAssigningPropsToState = new Set();
- didWarnAboutUndefinedDerivedState = new Set();
- didWarnAboutContextTypeAndContextTypes = new Set();
- didWarnAboutInvalidateContextType = new Set();
- var didWarnOnInvalidCallback = new Set();
-
- warnOnInvalidCallback = function (callback, callerName) {
- if (callback === null || typeof callback === 'function') {
- return;
- }
-
- var key = callerName + '_' + callback;
-
- if (!didWarnOnInvalidCallback.has(key)) {
- didWarnOnInvalidCallback.add(key);
-
- error('%s(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callerName, callback);
- }
- };
-
- warnOnUndefinedDerivedState = function (type, partialState) {
- if (partialState === undefined) {
- var componentName = getComponentNameFromType(type) || 'Component';
-
- if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
- didWarnAboutUndefinedDerivedState.add(componentName);
-
- error('%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. ' + 'You have returned undefined.', componentName);
- }
- }
- };
-}
-
-function warnNoop(publicInstance, callerName) {
- {
- var _constructor = publicInstance.constructor;
- var componentName = _constructor && getComponentNameFromType(_constructor) || 'ReactClass';
- var warningKey = componentName + '.' + callerName;
-
- if (didWarnAboutNoopUpdateForComponent[warningKey]) {
- return;
- }
-
- error('%s(...): Can only update a mounting component. ' + 'This usually means you called %s() outside componentWillMount() on the server. ' + 'This is a no-op.\n\nPlease check the code for the %s component.', callerName, callerName, componentName);
-
- didWarnAboutNoopUpdateForComponent[warningKey] = true;
- }
-}
-
-var classComponentUpdater = {
- isMounted: function (inst) {
- return false;
- },
- enqueueSetState: function (inst, payload, callback) {
- var internals = get(inst);
-
- if (internals.queue === null) {
- warnNoop(inst, 'setState');
- } else {
- internals.queue.push(payload);
-
- {
- if (callback !== undefined && callback !== null) {
- warnOnInvalidCallback(callback, 'setState');
- }
- }
- }
- },
- enqueueReplaceState: function (inst, payload, callback) {
- var internals = get(inst);
- internals.replace = true;
- internals.queue = [payload];
-
- {
- if (callback !== undefined && callback !== null) {
- warnOnInvalidCallback(callback, 'setState');
- }
- }
- },
- enqueueForceUpdate: function (inst, callback) {
- var internals = get(inst);
-
- if (internals.queue === null) {
- warnNoop(inst, 'forceUpdate');
- } else {
- {
- if (callback !== undefined && callback !== null) {
- warnOnInvalidCallback(callback, 'setState');
- }
- }
- }
- }
-};
-
-function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) {
- var partialState = getDerivedStateFromProps(nextProps, prevState);
-
- {
- warnOnUndefinedDerivedState(ctor, partialState);
- } // Merge the partial state and the previous state.
-
-
- var newState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
- return newState;
-}
-
-function constructClassInstance(ctor, props, maskedLegacyContext) {
- var context = emptyContextObject;
- var contextType = ctor.contextType;
-
- {
- if ('contextType' in ctor) {
- var isValid = // Allow null for conditional declaration
- contextType === null || contextType !== undefined && contextType.$$typeof === REACT_CONTEXT_TYPE && contextType._context === undefined; // Not a
-
- if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
- didWarnAboutInvalidateContextType.add(ctor);
- var addendum = '';
-
- if (contextType === undefined) {
- addendum = ' However, it is set to undefined. ' + 'This can be caused by a typo or by mixing up named and default imports. ' + 'This can also happen due to a circular dependency, so ' + 'try moving the createContext() call to a separate file.';
- } else if (typeof contextType !== 'object') {
- addendum = ' However, it is set to a ' + typeof contextType + '.';
- } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
- addendum = ' Did you accidentally pass the Context.Provider instead?';
- } else if (contextType._context !== undefined) {
- //
- addendum = ' Did you accidentally pass the Context.Consumer instead?';
- } else {
- addendum = ' However, it is set to an object with keys {' + Object.keys(contextType).join(', ') + '}.';
- }
-
- error('%s defines an invalid contextType. ' + 'contextType should point to the Context object returned by React.createContext().%s', getComponentNameFromType(ctor) || 'Component', addendum);
- }
- }
- }
-
- if (typeof contextType === 'object' && contextType !== null) {
- context = readContext(contextType);
- } else {
- context = maskedLegacyContext;
- }
-
- var instance = new ctor(props, context);
-
- {
- if (typeof ctor.getDerivedStateFromProps === 'function' && (instance.state === null || instance.state === undefined)) {
- var componentName = getComponentNameFromType(ctor) || 'Component';
-
- if (!didWarnAboutUninitializedState.has(componentName)) {
- didWarnAboutUninitializedState.add(componentName);
-
- error('`%s` uses `getDerivedStateFromProps` but its initial state is ' + '%s. This is not recommended. Instead, define the initial state by ' + 'assigning an object to `this.state` in the constructor of `%s`. ' + 'This ensures that `getDerivedStateFromProps` arguments have a consistent shape.', componentName, instance.state === null ? 'null' : 'undefined', componentName);
- }
- } // If new component APIs are defined, "unsafe" lifecycles won't be called.
- // Warn about these lifecycles if they are present.
- // Don't warn about react-lifecycles-compat polyfilled methods though.
-
-
- if (typeof ctor.getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function') {
- var foundWillMountName = null;
- var foundWillReceivePropsName = null;
- var foundWillUpdateName = null;
-
- if (typeof instance.componentWillMount === 'function' && instance.componentWillMount.__suppressDeprecationWarning !== true) {
- foundWillMountName = 'componentWillMount';
- } else if (typeof instance.UNSAFE_componentWillMount === 'function') {
- foundWillMountName = 'UNSAFE_componentWillMount';
- }
-
- if (typeof instance.componentWillReceiveProps === 'function' && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
- foundWillReceivePropsName = 'componentWillReceiveProps';
- } else if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {
- foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';
- }
-
- if (typeof instance.componentWillUpdate === 'function' && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
- foundWillUpdateName = 'componentWillUpdate';
- } else if (typeof instance.UNSAFE_componentWillUpdate === 'function') {
- foundWillUpdateName = 'UNSAFE_componentWillUpdate';
- }
-
- if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
- var _componentName = getComponentNameFromType(ctor) || 'Component';
-
- var newApiName = typeof ctor.getDerivedStateFromProps === 'function' ? 'getDerivedStateFromProps()' : 'getSnapshotBeforeUpdate()';
-
- if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
- didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
-
- error('Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' + '%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n' + 'The above lifecycles should be removed. Learn more about this warning here:\n' + 'https://reactjs.org/link/unsafe-component-lifecycles', _componentName, newApiName, foundWillMountName !== null ? "\n " + foundWillMountName : '', foundWillReceivePropsName !== null ? "\n " + foundWillReceivePropsName : '', foundWillUpdateName !== null ? "\n " + foundWillUpdateName : '');
- }
- }
- }
- }
-
- return instance;
-}
-
-function checkClassInstance(instance, ctor, newProps) {
- {
- var name = getComponentNameFromType(ctor) || 'Component';
- var renderPresent = instance.render;
-
- if (!renderPresent) {
- if (ctor.prototype && typeof ctor.prototype.render === 'function') {
- error('%s(...): No `render` method found on the returned component ' + 'instance: did you accidentally return an object from the constructor?', name);
- } else {
- error('%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', name);
- }
- }
-
- if (instance.getInitialState && !instance.getInitialState.isReactClassApproved && !instance.state) {
- error('getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', name);
- }
-
- if (instance.getDefaultProps && !instance.getDefaultProps.isReactClassApproved) {
- error('getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', name);
- }
-
- if (instance.propTypes) {
- error('propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', name);
- }
-
- if (instance.contextType) {
- error('contextType was defined as an instance property on %s. Use a static ' + 'property to define contextType instead.', name);
- }
-
- {
- if (instance.contextTypes) {
- error('contextTypes was defined as an instance property on %s. Use a static ' + 'property to define contextTypes instead.', name);
- }
-
- if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
- didWarnAboutContextTypeAndContextTypes.add(ctor);
-
- error('%s declares both contextTypes and contextType static properties. ' + 'The legacy contextTypes property will be ignored.', name);
- }
- }
-
- if (typeof instance.componentShouldUpdate === 'function') {
- error('%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', name);
- }
-
- if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== 'undefined') {
- error('%s has a method called shouldComponentUpdate(). ' + 'shouldComponentUpdate should not be used when extending React.PureComponent. ' + 'Please extend React.Component if shouldComponentUpdate is used.', getComponentNameFromType(ctor) || 'A pure component');
- }
-
- if (typeof instance.componentDidUnmount === 'function') {
- error('%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', name);
- }
-
- if (typeof instance.componentDidReceiveProps === 'function') {
- error('%s has a method called ' + 'componentDidReceiveProps(). But there is no such lifecycle method. ' + 'If you meant to update the state in response to changing props, ' + 'use componentWillReceiveProps(). If you meant to fetch data or ' + 'run side-effects or mutations after React has updated the UI, use componentDidUpdate().', name);
- }
-
- if (typeof instance.componentWillRecieveProps === 'function') {
- error('%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', name);
- }
-
- if (typeof instance.UNSAFE_componentWillRecieveProps === 'function') {
- error('%s has a method called ' + 'UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?', name);
- }
-
- var hasMutatedProps = instance.props !== newProps;
-
- if (instance.props !== undefined && hasMutatedProps) {
- error('%s(...): When calling super() in `%s`, make sure to pass ' + "up the same props that your component's constructor was passed.", name, name);
- }
-
- if (instance.defaultProps) {
- error('Setting defaultProps as an instance property on %s is not supported and will be ignored.' + ' Instead, define defaultProps as a static property on %s.', name, name);
- }
-
- if (typeof instance.getSnapshotBeforeUpdate === 'function' && typeof instance.componentDidUpdate !== 'function' && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
- didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
-
- error('%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). ' + 'This component defines getSnapshotBeforeUpdate() only.', getComponentNameFromType(ctor));
- }
-
- if (typeof instance.getDerivedStateFromProps === 'function') {
- error('%s: getDerivedStateFromProps() is defined as an instance method ' + 'and will be ignored. Instead, declare it as a static method.', name);
- }
-
- if (typeof instance.getDerivedStateFromError === 'function') {
- error('%s: getDerivedStateFromError() is defined as an instance method ' + 'and will be ignored. Instead, declare it as a static method.', name);
- }
-
- if (typeof ctor.getSnapshotBeforeUpdate === 'function') {
- error('%s: getSnapshotBeforeUpdate() is defined as a static method ' + 'and will be ignored. Instead, declare it as an instance method.', name);
- }
-
- var _state = instance.state;
-
- if (_state && (typeof _state !== 'object' || isArray(_state))) {
- error('%s.state: must be set to an object or null', name);
- }
-
- if (typeof instance.getChildContext === 'function' && typeof ctor.childContextTypes !== 'object') {
- error('%s.getChildContext(): childContextTypes must be defined in order to ' + 'use getChildContext().', name);
- }
- }
-}
-
-function callComponentWillMount(type, instance) {
- var oldState = instance.state;
-
- if (typeof instance.componentWillMount === 'function') {
- {
- if ( instance.componentWillMount.__suppressDeprecationWarning !== true) {
- var componentName = getComponentNameFromType(type) || 'Unknown';
-
- if (!didWarnAboutDeprecatedWillMount[componentName]) {
- warn( // keep this warning in sync with ReactStrictModeWarning.js
- 'componentWillMount has been renamed, and is not recommended for use. ' + 'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n' + '* Move code from componentWillMount to componentDidMount (preferred in most cases) ' + 'or the constructor.\n' + '\nPlease update the following components: %s', componentName);
-
- didWarnAboutDeprecatedWillMount[componentName] = true;
- }
- }
- }
-
- instance.componentWillMount();
- }
-
- if (typeof instance.UNSAFE_componentWillMount === 'function') {
- instance.UNSAFE_componentWillMount();
- }
-
- if (oldState !== instance.state) {
- {
- error('%s.componentWillMount(): Assigning directly to this.state is ' + "deprecated (except inside a component's " + 'constructor). Use setState instead.', getComponentNameFromType(type) || 'Component');
- }
-
- classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
- }
-}
-
-function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) {
- if (internalInstance.queue !== null && internalInstance.queue.length > 0) {
- var oldQueue = internalInstance.queue;
- var oldReplace = internalInstance.replace;
- internalInstance.queue = null;
- internalInstance.replace = false;
-
- if (oldReplace && oldQueue.length === 1) {
- inst.state = oldQueue[0];
- } else {
- var nextState = oldReplace ? oldQueue[0] : inst.state;
- var dontMutate = true;
-
- for (var i = oldReplace ? 1 : 0; i < oldQueue.length; i++) {
- var partial = oldQueue[i];
- var partialState = typeof partial === 'function' ? partial.call(inst, nextState, props, maskedLegacyContext) : partial;
-
- if (partialState != null) {
- if (dontMutate) {
- dontMutate = false;
- nextState = assign({}, nextState, partialState);
- } else {
- assign(nextState, partialState);
- }
- }
- }
-
- inst.state = nextState;
- }
- } else {
- internalInstance.queue = null;
- }
-} // Invokes the mount life-cycles on a previously never rendered instance.
-
-
-function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) {
- {
- checkClassInstance(instance, ctor, newProps);
- }
-
- var initialState = instance.state !== undefined ? instance.state : null;
- instance.updater = classComponentUpdater;
- instance.props = newProps;
- instance.state = initialState; // We don't bother initializing the refs object on the server, since we're not going to resolve them anyway.
- // The internal instance will be used to manage updates that happen during this mount.
-
- var internalInstance = {
- queue: [],
- replace: false
- };
- set(instance, internalInstance);
- var contextType = ctor.contextType;
-
- if (typeof contextType === 'object' && contextType !== null) {
- instance.context = readContext(contextType);
- } else {
- instance.context = maskedLegacyContext;
- }
-
- {
- if (instance.state === newProps) {
- var componentName = getComponentNameFromType(ctor) || 'Component';
-
- if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
- didWarnAboutDirectlyAssigningPropsToState.add(componentName);
-
- error('%s: It is not recommended to assign props directly to state ' + "because updates to props won't be reflected in state. " + 'In most cases, it is better to use props directly.', componentName);
- }
- }
- }
-
- var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-
- if (typeof getDerivedStateFromProps === 'function') {
- instance.state = applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, initialState, newProps);
- } // In order to support react-lifecycles-compat polyfilled components,
- // Unsafe lifecycles should not be invoked for components using the new APIs.
-
-
- if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {
- callComponentWillMount(ctor, instance); // If we had additional state updates during this life-cycle, let's
- // process them now.
-
- processUpdateQueue(internalInstance, instance, newProps, maskedLegacyContext);
- }
-}
-
-// Ids are base 32 strings whose binary representation corresponds to the
-// position of a node in a tree.
-// Every time the tree forks into multiple children, we add additional bits to
-// the left of the sequence that represent the position of the child within the
-// current level of children.
-//
-// 00101 00010001011010101
-// ╰─┬─╯ ╰───────┬───────╯
-// Fork 5 of 20 Parent id
-//
-// The leading 0s are important. In the above example, you only need 3 bits to
-// represent slot 5. However, you need 5 bits to represent all the forks at
-// the current level, so we must account for the empty bits at the end.
-//
-// For this same reason, slots are 1-indexed instead of 0-indexed. Otherwise,
-// the zeroth id at a level would be indistinguishable from its parent.
-//
-// If a node has only one child, and does not materialize an id (i.e. does not
-// contain a useId hook), then we don't need to allocate any space in the
-// sequence. It's treated as a transparent indirection. For example, these two
-// trees produce the same ids:
-//
-// <> <>
-//
-//
-// >
-//
-// >
-//
-// However, we cannot skip any node that materializes an id. Otherwise, a parent
-// id that does not fork would be indistinguishable from its child id. For
-// example, this tree does not fork, but the parent and child must have
-// different ids.
-//
-//
-//
-//
-//
-// To handle this scenario, every time we materialize an id, we allocate a
-// new level with a single slot. You can think of this as a fork with only one
-// prong, or an array of children with length 1.
-//
-// It's possible for the size of the sequence to exceed 32 bits, the max
-// size for bitwise operations. When this happens, we make more room by
-// converting the right part of the id to a string and storing it in an overflow
-// variable. We use a base 32 string representation, because 32 is the largest
-// power of 2 that is supported by toString(). We want the base to be large so
-// that the resulting ids are compact, and we want the base to be a power of 2
-// because every log2(base) bits corresponds to a single character, i.e. every
-// log2(32) = 5 bits. That means we can lop bits off the end 5 at a time without
-// affecting the final result.
-var emptyTreeContext = {
- id: 1,
- overflow: ''
-};
-function getTreeId(context) {
- var overflow = context.overflow;
- var idWithLeadingBit = context.id;
- var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
- return id.toString(32) + overflow;
-}
-function pushTreeContext(baseContext, totalChildren, index) {
- var baseIdWithLeadingBit = baseContext.id;
- var baseOverflow = baseContext.overflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
- // of the id; we use it to account for leading 0s.
-
- var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
- var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
- var slot = index + 1;
- var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
- // consideration the leading 1 we use to mark the end of the sequence.
-
- if (length > 30) {
- // We overflowed the bitwise-safe range. Fall back to slower algorithm.
- // This branch assumes the length of the base id is greater than 5; it won't
- // work for smaller ids, because you need 5 bits per character.
- //
- // We encode the id in multiple steps: first the base id, then the
- // remaining digits.
- //
- // Each 5 bit sequence corresponds to a single base 32 character. So for
- // example, if the current id is 23 bits long, we can convert 20 of those
- // bits into a string of 4 characters, with 3 bits left over.
- //
- // First calculate how many bits in the base id represent a complete
- // sequence of characters.
- var numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.
-
- var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
-
- var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
-
- var restOfBaseId = baseId >> numberOfOverflowBits;
- var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
- // we made more room, this time it won't overflow.
-
- var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
- var restOfNewBits = slot << restOfBaseLength;
- var id = restOfNewBits | restOfBaseId;
- var overflow = newOverflow + baseOverflow;
- return {
- id: 1 << restOfLength | id,
- overflow: overflow
- };
- } else {
- // Normal path
- var newBits = slot << baseLength;
-
- var _id = newBits | baseId;
-
- var _overflow = baseOverflow;
- return {
- id: 1 << length | _id,
- overflow: _overflow
- };
- }
-}
-
-function getBitLength(number) {
- return 32 - clz32(number);
-}
-
-function getLeadingBit(id) {
- return 1 << getBitLength(id) - 1;
-} // TODO: Math.clz32 is supported in Node 12+. Maybe we can drop the fallback.
-
-
-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;
-}
-
-// Corresponds to ReactFiberWakeable and ReactFlightWakeable modules. Generally,
-// changes to one module should be reflected in the others.
-// TODO: Rename this module and the corresponding Fiber one to "Thenable"
-// instead of "Wakeable". Or some other more appropriate name.
-// An error that is thrown (e.g. by `use`) to trigger Suspense. If we
-// detect this is caught by userspace, we'll log a warning in development.
-var SuspenseException = new 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\n' + 'To handle async errors, wrap your component in an error boundary, or ' + "call the promise's `.catch` method and pass the result to `use`");
-function createThenableState() {
- // The ThenableState is created the first time a component suspends. If it
- // suspends again, we'll reuse the same state.
- return [];
-}
-
-function noop() {}
-
-function trackUsedThenable(thenableState, thenable, index) {
- var previous = thenableState[index];
-
- if (previous === undefined) {
- thenableState.push(thenable);
- } else {
- if (previous !== thenable) {
- // Reuse the previous thenable, and drop the new one. We can assume
- // they represent the same value, because components are idempotent.
- // Avoid an unhandled rejection errors for the Promises that we'll
- // intentionally ignore.
- thenable.then(noop, noop);
- thenable = previous;
- }
- } // We use an expando to track the status and result of a thenable so that we
- // can synchronously unwrap the value. Think of this as an extension of the
- // Promise API, or a custom interface that is a superset of Thenable.
- //
- // If the thenable doesn't have a status, set it to "pending" and attach
- // a listener that will update its status and result when it resolves.
-
-
- switch (thenable.status) {
- case 'fulfilled':
- {
- var fulfilledValue = thenable.value;
- return fulfilledValue;
- }
-
- case 'rejected':
- {
- var rejectedError = thenable.reason;
- throw rejectedError;
- }
-
- default:
- {
- if (typeof thenable.status === 'string') ; else {
- var pendingThenable = thenable;
- pendingThenable.status = 'pending';
- pendingThenable.then(function (fulfilledValue) {
- if (thenable.status === 'pending') {
- var fulfilledThenable = thenable;
- fulfilledThenable.status = 'fulfilled';
- fulfilledThenable.value = fulfilledValue;
- }
- }, function (error) {
- if (thenable.status === 'pending') {
- var rejectedThenable = thenable;
- rejectedThenable.status = 'rejected';
- rejectedThenable.reason = error;
- }
- }); // Check one more time in case the thenable resolved synchronously
-
- switch (thenable.status) {
- case 'fulfilled':
- {
- var fulfilledThenable = thenable;
- return fulfilledThenable.value;
- }
-
- case 'rejected':
- {
- var rejectedThenable = thenable;
- throw rejectedThenable.reason;
- }
- }
- } // Suspend.
- //
- // Throwing here is an implementation detail that allows us to unwind the
- // call stack. But we shouldn't allow it to leak into userspace. Throw an
- // opaque placeholder value instead of the actual thenable. If it doesn't
- // get captured by the work loop, log a warning, because that means
- // something in userspace must have caught it.
-
-
- suspendedThenable = thenable;
- throw SuspenseException;
- }
- }
-} // This is used to track the actual thenable that suspended so it can be
-// passed to the rest of the Suspense implementation — which, for historical
-// reasons, expects to receive a thenable.
-
-var suspendedThenable = null;
-function getSuspendedThenable() {
- // This is called right after `use` suspends by throwing an exception. `use`
- // throws an opaque value instead of the thenable itself so that it can't be
- // caught in userspace. Then the work loop accesses the actual thenable using
- // this function.
- if (suspendedThenable === null) {
- throw new Error('Expected a suspended thenable. This is a bug in React. Please file ' + 'an issue.');
- }
-
- var thenable = suspendedThenable;
- suspendedThenable = null;
- return thenable;
-}
-
-/**
- * inlined Object.is polyfill to avoid requiring consumers ship their own
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
- */
-function is(x, y) {
- return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
- ;
-}
-
-var objectIs = // $FlowFixMe[method-unbinding]
-typeof Object.is === 'function' ? Object.is : is;
-
-var currentlyRenderingComponent = null;
-var currentlyRenderingTask = null;
-var firstWorkInProgressHook = null;
-var workInProgressHook = null; // Whether the work-in-progress hook is a re-rendered hook
-
-var isReRender = false; // Whether an update was scheduled during the currently executing render pass.
-
-var didScheduleRenderPhaseUpdate = false; // Counts the number of useId hooks in this component
-
-var localIdCounter = 0; // Counts the number of use(thenable) calls in this component
-
-var thenableIndexCounter = 0;
-var thenableState = null; // Lazily created map of render-phase updates
-
-var renderPhaseUpdates = null; // Counter to prevent infinite loops.
-
-var numberOfReRenders = 0;
-var RE_RENDER_LIMIT = 25;
-var isInHookUserCodeInDev = false; // In DEV, this is the name of the currently executing primitive hook
-
-var currentHookNameInDev;
-
-function resolveCurrentlyRenderingComponent() {
- if (currentlyRenderingComponent === null) {
- throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
- }
-
- {
- if (isInHookUserCodeInDev) {
- error('Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. ' + 'You can only call Hooks at the top level of your React function. ' + 'For more information, see ' + 'https://reactjs.org/link/rules-of-hooks');
- }
- }
-
- return currentlyRenderingComponent;
-}
-
-function areHookInputsEqual(nextDeps, prevDeps) {
- if (prevDeps === null) {
- {
- error('%s received a final argument during this render, but not during ' + 'the previous render. Even though the final argument is optional, ' + 'its type cannot change between renders.', currentHookNameInDev);
- }
-
- return false;
- }
-
- {
- // Don't bother comparing lengths in prod because these arrays should be
- // passed inline.
- if (nextDeps.length !== prevDeps.length) {
- error('The final argument passed to %s changed size between renders. The ' + 'order and size of this array must remain constant.\n\n' + 'Previous: %s\n' + 'Incoming: %s', currentHookNameInDev, "[" + nextDeps.join(', ') + "]", "[" + prevDeps.join(', ') + "]");
- }
- } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
- // $FlowFixMe[incompatible-use] found when upgrading Flow
- if (objectIs(nextDeps[i], prevDeps[i])) {
- continue;
- }
-
- return false;
- }
-
- return true;
-}
-
-function createHook() {
- if (numberOfReRenders > 0) {
- throw new Error('Rendered more hooks than during the previous render');
- }
-
- return {
- memoizedState: null,
- queue: null,
- next: null
- };
-}
-
-function createWorkInProgressHook() {
- if (workInProgressHook === null) {
- // This is the first hook in the list
- if (firstWorkInProgressHook === null) {
- isReRender = false;
- firstWorkInProgressHook = workInProgressHook = createHook();
- } else {
- // There's already a work-in-progress. Reuse it.
- isReRender = true;
- workInProgressHook = firstWorkInProgressHook;
- }
- } else {
- if (workInProgressHook.next === null) {
- isReRender = false; // Append to the end of the list
-
- workInProgressHook = workInProgressHook.next = createHook();
- } else {
- // There's already a work-in-progress. Reuse it.
- isReRender = true;
- workInProgressHook = workInProgressHook.next;
- }
- }
-
- return workInProgressHook;
-}
-
-function prepareToUseHooks(task, componentIdentity, prevThenableState) {
- currentlyRenderingComponent = componentIdentity;
- currentlyRenderingTask = task;
-
- {
- isInHookUserCodeInDev = false;
- } // The following should have already been reset
- // didScheduleRenderPhaseUpdate = false;
- // firstWorkInProgressHook = null;
- // numberOfReRenders = 0;
- // renderPhaseUpdates = null;
- // workInProgressHook = null;
-
-
- localIdCounter = 0;
- thenableIndexCounter = 0;
- thenableState = prevThenableState;
-}
-function finishHooks(Component, props, children, refOrContext) {
- // This must be called after every function component to prevent hooks from
- // being used in classes.
- while (didScheduleRenderPhaseUpdate) {
- // Updates were scheduled during the render phase. They are stored in
- // the `renderPhaseUpdates` map. Call the component again, reusing the
- // work-in-progress hooks and applying the additional updates on top. Keep
- // restarting until no more updates are scheduled.
- didScheduleRenderPhaseUpdate = false;
- localIdCounter = 0;
- thenableIndexCounter = 0;
- numberOfReRenders += 1; // Start over from the beginning of the list
-
- workInProgressHook = null;
- children = Component(props, refOrContext);
- }
-
- resetHooksState();
- return children;
-}
-function getThenableStateAfterSuspending() {
- var state = thenableState;
- thenableState = null;
- return state;
-}
-function checkDidRenderIdHook() {
- // This should be called immediately after every finishHooks call.
- // Conceptually, it's part of the return value of finishHooks; it's only a
- // separate function to avoid using an array tuple.
- var didRenderIdHook = localIdCounter !== 0;
- return didRenderIdHook;
-} // Reset the internal hooks state if an error occurs while rendering a component
-
-function resetHooksState() {
- {
- isInHookUserCodeInDev = false;
- }
-
- currentlyRenderingComponent = null;
- currentlyRenderingTask = null;
- didScheduleRenderPhaseUpdate = false;
- firstWorkInProgressHook = null;
- numberOfReRenders = 0;
- renderPhaseUpdates = null;
- workInProgressHook = null;
-}
-
-function readContext$1(context) {
- {
- if (isInHookUserCodeInDev) {
- error('Context can only be read while React is rendering. ' + 'In classes, you can read it in the render method or getDerivedStateFromProps. ' + 'In function components, you can read it directly in the function body, but not ' + 'inside Hooks like useReducer() or useMemo().');
- }
- }
-
- return readContext(context);
-}
-
-function useContext(context) {
- {
- currentHookNameInDev = 'useContext';
- }
-
- resolveCurrentlyRenderingComponent();
- return readContext(context);
-}
-
-function basicStateReducer(state, action) {
- // $FlowFixMe: Flow doesn't like mixed types
- return typeof action === 'function' ? action(state) : action;
-}
-
-function useState(initialState) {
- {
- currentHookNameInDev = 'useState';
- }
-
- return useReducer(basicStateReducer, // useReducer has a special case to support lazy useState initializers
- initialState);
-}
-function useReducer(reducer, initialArg, init) {
- {
- if (reducer !== basicStateReducer) {
- currentHookNameInDev = 'useReducer';
- }
- }
-
- currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
- workInProgressHook = createWorkInProgressHook();
-
- if (isReRender) {
- // This is a re-render. Apply the new render phase updates to the previous
- // current hook.
- var queue = workInProgressHook.queue;
- var dispatch = queue.dispatch;
-
- if (renderPhaseUpdates !== null) {
- // Render phase updates are stored in a map of queue -> linked list
- var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
-
- if (firstRenderPhaseUpdate !== undefined) {
- // $FlowFixMe[incompatible-use] found when upgrading Flow
- renderPhaseUpdates.delete(queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
-
- var newState = workInProgressHook.memoizedState;
- var update = firstRenderPhaseUpdate;
-
- do {
- // Process this render phase update. We don't have to check the
- // priority because it will always be the same as the current
- // render's.
- var action = update.action;
-
- {
- isInHookUserCodeInDev = true;
- }
-
- newState = reducer(newState, action);
-
- {
- isInHookUserCodeInDev = false;
- } // $FlowFixMe[incompatible-type] we bail out when we get a null
-
-
- update = update.next;
- } while (update !== null); // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- workInProgressHook.memoizedState = newState;
- return [newState, dispatch];
- }
- } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- return [workInProgressHook.memoizedState, dispatch];
- } else {
- {
- isInHookUserCodeInDev = true;
- }
-
- var initialState;
-
- if (reducer === basicStateReducer) {
- // Special case for `useState`.
- initialState = typeof initialArg === 'function' ? initialArg() : initialArg;
- } else {
- initialState = init !== undefined ? init(initialArg) : initialArg;
- }
-
- {
- isInHookUserCodeInDev = false;
- } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- workInProgressHook.memoizedState = initialState; // $FlowFixMe[incompatible-use] found when upgrading Flow
-
- var _queue = workInProgressHook.queue = {
- last: null,
- dispatch: null
- };
-
- var _dispatch = _queue.dispatch = dispatchAction.bind(null, currentlyRenderingComponent, _queue); // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- return [workInProgressHook.memoizedState, _dispatch];
- }
-}
-
-function useMemo(nextCreate, deps) {
- currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
- workInProgressHook = createWorkInProgressHook();
- var nextDeps = deps === undefined ? null : deps;
-
- if (workInProgressHook !== null) {
- var prevState = workInProgressHook.memoizedState;
-
- if (prevState !== null) {
- if (nextDeps !== null) {
- var prevDeps = prevState[1];
-
- if (areHookInputsEqual(nextDeps, prevDeps)) {
- return prevState[0];
- }
- }
- }
- }
-
- {
- isInHookUserCodeInDev = true;
- }
-
- var nextValue = nextCreate();
-
- {
- isInHookUserCodeInDev = false;
- } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- workInProgressHook.memoizedState = [nextValue, nextDeps];
- return nextValue;
-}
-
-function useRef(initialValue) {
- currentlyRenderingComponent = resolveCurrentlyRenderingComponent();
- workInProgressHook = createWorkInProgressHook();
- var previousRef = workInProgressHook.memoizedState;
-
- if (previousRef === null) {
- var ref = {
- current: initialValue
- };
-
- {
- Object.seal(ref);
- } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-
- workInProgressHook.memoizedState = ref;
- return ref;
- } else {
- return previousRef;
- }
-}
-
-function useLayoutEffect(create, inputs) {
- {
- currentHookNameInDev = 'useLayoutEffect';
-
- error('useLayoutEffect does nothing on the server, because its effect cannot ' + "be encoded into the server renderer's output format. This will lead " + 'to a mismatch between the initial, non-hydrated UI and the intended ' + 'UI. To avoid this, useLayoutEffect should only be used in ' + 'components that render exclusively on the client. ' + 'See https://reactjs.org/link/uselayouteffect-ssr for common fixes.');
- }
-}
-
-function dispatchAction(componentIdentity, queue, action) {
- if (numberOfReRenders >= RE_RENDER_LIMIT) {
- throw new Error('Too many re-renders. React limits the number of renders to prevent ' + 'an infinite loop.');
- }
-
- if (componentIdentity === currentlyRenderingComponent) {
- // This is a render phase update. Stash it in a lazily-created map of
- // queue -> linked list of updates. After this render pass, we'll restart
- // and apply the stashed updates on top of the work-in-progress hook.
- didScheduleRenderPhaseUpdate = true;
- var update = {
- action: action,
- next: null
- };
-
- if (renderPhaseUpdates === null) {
- renderPhaseUpdates = new Map();
- }
-
- var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
-
- if (firstRenderPhaseUpdate === undefined) {
- // $FlowFixMe[incompatible-use] found when upgrading Flow
- renderPhaseUpdates.set(queue, update);
- } else {
- // Append the update to the end of the list.
- var lastRenderPhaseUpdate = firstRenderPhaseUpdate;
-
- while (lastRenderPhaseUpdate.next !== null) {
- lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
- }
-
- lastRenderPhaseUpdate.next = update;
- }
- }
-}
-
-function useCallback(callback, deps) {
- return useMemo(function () {
- return callback;
- }, deps);
-}
-// If a mutation occurs during render, consider triggering a Suspense boundary
-// and falling back to client rendering.
-
-function useMutableSource(source, getSnapshot, subscribe) {
- resolveCurrentlyRenderingComponent();
- return getSnapshot(source._source);
-}
-
-function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
- if (getServerSnapshot === undefined) {
- throw new Error('Missing getServerSnapshot, which is required for ' + 'server-rendered content. Will revert to client rendering.');
- }
-
- return getServerSnapshot();
-}
-
-function useDeferredValue(value) {
- resolveCurrentlyRenderingComponent();
- return value;
-}
-
-function unsupportedStartTransition() {
- throw new Error('startTransition cannot be called during server rendering.');
-}
-
-function useTransition() {
- resolveCurrentlyRenderingComponent();
- return [false, unsupportedStartTransition];
-}
-
-function useId() {
- var task = currentlyRenderingTask;
- var treeId = getTreeId(task.treeContext);
- var responseState = currentResponseState;
-
- if (responseState === null) {
- throw new Error('Invalid hook call. Hooks can only be called inside of the body of a function component.');
- }
-
- var localId = localIdCounter++;
- return makeId(responseState, treeId, localId);
-}
-
-function use(usable) {
- if (usable !== null && typeof usable === 'object') {
- // $FlowFixMe[method-unbinding]
- if (typeof usable.then === 'function') {
- // This is a thenable.
- var thenable = usable; // Track the position of the thenable within this fiber.
-
- var index = thenableIndexCounter;
- thenableIndexCounter += 1;
-
- if (thenableState === null) {
- thenableState = createThenableState();
- }
-
- return trackUsedThenable(thenableState, thenable, index);
- } else if (usable.$$typeof === REACT_CONTEXT_TYPE || usable.$$typeof === REACT_SERVER_CONTEXT_TYPE) {
- var context = usable;
- return readContext$1(context);
- }
- } // eslint-disable-next-line react-internal/safe-string-coercion
-
-
- throw new Error('An unsupported type was passed to use(): ' + String(usable));
-}
-
-function unsupportedRefresh() {
- throw new Error('Cache cannot be refreshed during server rendering.');
-}
-
-function useCacheRefresh() {
- return unsupportedRefresh;
-}
-
-function noop$1() {}
-
-var HooksDispatcher = {
- readContext: readContext$1,
- useContext: useContext,
- useMemo: useMemo,
- useReducer: useReducer,
- useRef: useRef,
- useState: useState,
- useInsertionEffect: noop$1,
- useLayoutEffect: useLayoutEffect,
- useCallback: useCallback,
- // useImperativeHandle is not run in the server environment
- useImperativeHandle: noop$1,
- // Effects are not run in the server environment.
- useEffect: noop$1,
- // Debugging effect
- useDebugValue: noop$1,
- useDeferredValue: useDeferredValue,
- useTransition: useTransition,
- useId: useId,
- // Subscriptions are not setup in a server environment.
- useMutableSource: useMutableSource,
- useSyncExternalStore: useSyncExternalStore
-};
-
-{
- HooksDispatcher.useCacheRefresh = useCacheRefresh;
-}
-
-{
- HooksDispatcher.use = use;
-}
-
-var currentResponseState = null;
-function setCurrentResponseState(responseState) {
- currentResponseState = responseState;
-}
-
-function getCacheSignal() {
- throw new Error('Not implemented.');
-}
-
-function getCacheForType(resourceType) {
- throw new Error('Not implemented.');
-}
-
-var DefaultCacheDispatcher = {
- getCacheSignal: getCacheSignal,
- getCacheForType: getCacheForType
-};
-
-function getStackByComponentStackNode(componentStack) {
- try {
- var info = '';
- var node = componentStack;
-
- do {
- switch (node.tag) {
- case 0:
- info += describeBuiltInComponentFrame(node.type, null, null);
- break;
-
- case 1:
- info += describeFunctionComponentFrame(node.type, null, null);
- break;
-
- case 2:
- info += describeClassComponentFrame(node.type, null, null);
- break;
- } // $FlowFixMe[incompatible-type] we bail out when we get a null
-
-
- node = node.parent;
- } while (node);
-
- return info;
- } catch (x) {
- return '\nError generating stack: ' + x.message + '\n' + x.stack;
- }
-}
-
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
-var ReactCurrentCache = ReactSharedInternals.ReactCurrentCache;
-var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
-var PENDING = 0;
-var COMPLETED = 1;
-var FLUSHED = 2;
-var ABORTED = 3;
-var ERRORED = 4;
-var OPEN = 0;
-var CLOSING = 1;
-var CLOSED = 2;
-// This is a default heuristic for how to split up the HTML content into progressive
-// loading. Our goal is to be able to display additional new content about every 500ms.
-// Faster than that is unnecessary and should be throttled on the client. It also
-// adds unnecessary overhead to do more splits. We don't know if it's a higher or lower
-// end device but higher end suffer less from the overhead than lower end does from
-// not getting small enough pieces. We error on the side of low end.
-// We base this on low end 3G speeds which is about 500kbits per second. We assume
-// that there can be a reasonable drop off from max bandwidth which leaves you with
-// as little as 80%. We can receive half of that each 500ms - at best. In practice,
-// a little bandwidth is lost to processing and contention - e.g. CSS and images that
-// are downloaded along with the main content. So we estimate about half of that to be
-// the lower end throughput. In other words, we expect that you can at least show
-// about 12.5kb of content per 500ms. Not counting starting latency for the first
-// paint.
-// 500 * 1024 / 8 * .8 * 0.5 / 2
-var DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
-
-function defaultErrorHandler(error) {
- console['error'](error); // Don't transform to our wrapper
-
- return null;
-}
-
-function noop$2() {}
-
-function createRequest(children, responseState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError) {
- var pingedTasks = [];
- var abortSet = new Set();
- var resources = createResources();
- var request = {
- destination: null,
- responseState: responseState,
- progressiveChunkSize: progressiveChunkSize === undefined ? DEFAULT_PROGRESSIVE_CHUNK_SIZE : progressiveChunkSize,
- status: OPEN,
- fatalError: null,
- nextSegmentId: 0,
- allPendingTasks: 0,
- pendingRootTasks: 0,
- resources: resources,
- completedRootSegment: null,
- abortableTasks: abortSet,
- pingedTasks: pingedTasks,
- clientRenderedBoundaries: [],
- completedBoundaries: [],
- partialBoundaries: [],
- preamble: [],
- postamble: [],
- onError: onError === undefined ? defaultErrorHandler : onError,
- onAllReady: onAllReady === undefined ? noop$2 : onAllReady,
- onShellReady: onShellReady === undefined ? noop$2 : onShellReady,
- onShellError: onShellError === undefined ? noop$2 : onShellError,
- onFatalError: onFatalError === undefined ? noop$2 : onFatalError
- }; // This segment represents the root fallback.
-
- var rootSegment = createPendingSegment(request, 0, null, rootFormatContext, // Root segments are never embedded in Text on either edge
- false, false); // There is no parent so conceptually, we're unblocked to flush this segment.
-
- rootSegment.parentFlushed = true;
- var rootTask = createTask(request, null, children, null, rootSegment, abortSet, emptyContextObject, rootContextSnapshot, emptyTreeContext);
- pingedTasks.push(rootTask);
- return request;
-}
-
-function pingTask(request, task) {
- var pingedTasks = request.pingedTasks;
- pingedTasks.push(task);
-
- if (pingedTasks.length === 1) {
- scheduleWork(function () {
- return performWork(request);
- });
- }
-}
-
-function createSuspenseBoundary(request, fallbackAbortableTasks) {
- return {
- id: UNINITIALIZED_SUSPENSE_BOUNDARY_ID,
- rootSegmentID: -1,
- parentFlushed: false,
- pendingTasks: 0,
- forceClientRender: false,
- completedSegments: [],
- byteSize: 0,
- fallbackAbortableTasks: fallbackAbortableTasks,
- errorDigest: null,
- resources: createBoundaryResources()
- };
-}
-
-function createTask(request, thenableState, node, blockedBoundary, blockedSegment, abortSet, legacyContext, context, treeContext) {
- request.allPendingTasks++;
-
- if (blockedBoundary === null) {
- request.pendingRootTasks++;
- } else {
- blockedBoundary.pendingTasks++;
- }
-
- var task = {
- node: node,
- ping: function () {
- return pingTask(request, task);
- },
- blockedBoundary: blockedBoundary,
- blockedSegment: blockedSegment,
- abortSet: abortSet,
- legacyContext: legacyContext,
- context: context,
- treeContext: treeContext,
- thenableState: thenableState
- };
-
- {
- task.componentStack = null;
- }
-
- abortSet.add(task);
- return task;
-}
-
-function createPendingSegment(request, index, boundary, formatContext, lastPushedText, textEmbedded) {
- return {
- status: PENDING,
- id: -1,
- // lazily assigned later
- index: index,
- parentFlushed: false,
- chunks: [],
- children: [],
- formatContext: formatContext,
- boundary: boundary,
- lastPushedText: lastPushedText,
- textEmbedded: textEmbedded
- };
-} // DEV-only global reference to the currently executing task
-
-
-var currentTaskInDEV = null;
-
-function getCurrentStackInDEV() {
- {
- if (currentTaskInDEV === null || currentTaskInDEV.componentStack === null) {
- return '';
- }
-
- return getStackByComponentStackNode(currentTaskInDEV.componentStack);
- }
-}
-
-function pushBuiltInComponentStackInDEV(task, type) {
- {
- task.componentStack = {
- tag: 0,
- parent: task.componentStack,
- type: type
- };
- }
-}
-
-function pushFunctionComponentStackInDEV(task, type) {
- {
- task.componentStack = {
- tag: 1,
- parent: task.componentStack,
- type: type
- };
- }
-}
-
-function pushClassComponentStackInDEV(task, type) {
- {
- task.componentStack = {
- tag: 2,
- parent: task.componentStack,
- type: type
- };
- }
-}
-
-function popComponentStackInDEV(task) {
- {
- if (task.componentStack === null) {
- error('Unexpectedly popped too many stack frames. This is a bug in React.');
- } else {
- task.componentStack = task.componentStack.parent;
- }
- }
-} // stash the component stack of an unwinding error until it is processed
-
-
-var lastBoundaryErrorComponentStackDev = null;
-
-function captureBoundaryErrorDetailsDev(boundary, error) {
- {
- var errorMessage;
-
- if (typeof error === 'string') {
- errorMessage = error;
- } else if (error && typeof error.message === 'string') {
- errorMessage = error.message;
- } else {
- // eslint-disable-next-line react-internal/safe-string-coercion
- errorMessage = String(error);
- }
-
- var errorComponentStack = lastBoundaryErrorComponentStackDev || getCurrentStackInDEV();
- lastBoundaryErrorComponentStackDev = null;
- boundary.errorMessage = errorMessage;
- boundary.errorComponentStack = errorComponentStack;
- }
-}
-
-function logRecoverableError(request, error) {
- // If this callback errors, we intentionally let that error bubble up to become a fatal error
- // so that someone fixes the error reporting instead of hiding it.
- var errorDigest = request.onError(error);
-
- if (errorDigest != null && typeof errorDigest !== 'string') {
- // eslint-disable-next-line react-internal/prod-error-codes
- throw new Error("onError returned something with a type other than \"string\". onError should return a string and may return null or undefined but must not return anything else. It received something of type \"" + typeof errorDigest + "\" instead");
- }
-
- return errorDigest;
-}
-
-function fatalError(request, error) {
- // This is called outside error handling code such as if the root errors outside
- // a suspense boundary or if the root suspense boundary's fallback errors.
- // It's also called if React itself or its host configs errors.
- var onShellError = request.onShellError;
- onShellError(error);
- var onFatalError = request.onFatalError;
- onFatalError(error);
-
- if (request.destination !== null) {
- request.status = CLOSED;
- closeWithError(request.destination, error);
- } else {
- request.status = CLOSING;
- request.fatalError = error;
- }
-}
-
-function renderSuspenseBoundary(request, task, props) {
- pushBuiltInComponentStackInDEV(task, 'Suspense');
- var parentBoundary = task.blockedBoundary;
- var parentSegment = task.blockedSegment; // Each time we enter a suspense boundary, we split out into a new segment for
- // the fallback so that we can later replace that segment with the content.
- // This also lets us split out the main content even if it doesn't suspend,
- // in case it ends up generating a large subtree of content.
-
- var fallback = props.fallback;
- var content = props.children;
- var fallbackAbortSet = new Set();
- var newBoundary = createSuspenseBoundary(request, fallbackAbortSet);
- var insertionIndex = parentSegment.chunks.length; // The children of the boundary segment is actually the fallback.
-
- var boundarySegment = createPendingSegment(request, insertionIndex, newBoundary, parentSegment.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
- false, false);
- parentSegment.children.push(boundarySegment); // The parentSegment has a child Segment at this index so we reset the lastPushedText marker on the parent
-
- parentSegment.lastPushedText = false; // This segment is the actual child content. We can start rendering that immediately.
-
- var contentRootSegment = createPendingSegment(request, 0, null, parentSegment.formatContext, // boundaries never require text embedding at their edges because comment nodes bound them
- false, false); // We mark the root segment as having its parent flushed. It's not really flushed but there is
- // no parent segment so there's nothing to wait on.
-
- contentRootSegment.parentFlushed = true; // Currently this is running synchronously. We could instead schedule this to pingedTasks.
- // I suspect that there might be some efficiency benefits from not creating the suspended task
- // and instead just using the stack if possible.
- // TODO: Call this directly instead of messing with saving and restoring contexts.
- // We can reuse the current context and task to render the content immediately without
- // context switching. We just need to temporarily switch which boundary and which segment
- // we're writing to. If something suspends, it'll spawn new suspended task with that context.
-
- task.blockedBoundary = newBoundary;
- task.blockedSegment = contentRootSegment;
-
- {
- setCurrentlyRenderingBoundaryResourcesTarget(request.resources, newBoundary.resources);
- }
-
- try {
- // We use the safe form because we don't handle suspending here. Only error handling.
- renderNode(request, task, content);
- pushSegmentFinale(contentRootSegment.chunks, request.responseState, contentRootSegment.lastPushedText, contentRootSegment.textEmbedded);
- contentRootSegment.status = COMPLETED;
-
- if (enableFloat) {
- if (newBoundary.pendingTasks === 0) {
- hoistCompletedBoundaryResources(request, newBoundary);
- }
- }
-
- queueCompletedSegment(newBoundary, contentRootSegment);
-
- if (newBoundary.pendingTasks === 0) {
- // This must have been the last segment we were waiting on. This boundary is now complete.
- // Therefore we won't need the fallback. We early return so that we don't have to create
- // the fallback.
- popComponentStackInDEV(task);
- return;
- }
- } catch (error) {
- contentRootSegment.status = ERRORED;
- newBoundary.forceClientRender = true;
- newBoundary.errorDigest = logRecoverableError(request, error);
-
- {
- captureBoundaryErrorDetailsDev(newBoundary, error);
- } // We don't need to decrement any task numbers because we didn't spawn any new task.
- // We don't need to schedule any task because we know the parent has written yet.
- // We do need to fallthrough to create the fallback though.
-
- } finally {
- {
- setCurrentlyRenderingBoundaryResourcesTarget(request.resources, parentBoundary ? parentBoundary.resources : null);
- }
-
- task.blockedBoundary = parentBoundary;
- task.blockedSegment = parentSegment;
- } // We create suspended task for the fallback because we don't want to actually work
- // on it yet in case we finish the main content, so we queue for later.
-
-
- var suspendedFallbackTask = createTask(request, null, fallback, parentBoundary, boundarySegment, fallbackAbortSet, task.legacyContext, task.context, task.treeContext);
-
- {
- suspendedFallbackTask.componentStack = task.componentStack;
- } // TODO: This should be queued at a separate lower priority queue so that we only work
- // on preparing fallbacks if we don't have any more main content to task on.
-
-
- request.pingedTasks.push(suspendedFallbackTask);
- popComponentStackInDEV(task);
-}
-
-function hoistCompletedBoundaryResources(request, completedBoundary) {
- if (request.completedRootSegment !== null || request.pendingRootTasks > 0) {
- // The Shell has not flushed yet. we can hoist Resources for this boundary
- // all the way to the Root.
- hoistResourcesToRoot(request.resources, completedBoundary.resources);
- } // We don't hoist if the root already flushed because late resources will be hoisted
- // as boundaries flush
-
-}
-
-function renderHostElement(request, task, type, props) {
- pushBuiltInComponentStackInDEV(task, type);
- var segment = task.blockedSegment;
- var children = pushStartInstance(segment.chunks, request.preamble, type, props, request.responseState, segment.formatContext, segment.lastPushedText);
- segment.lastPushedText = false;
- var prevContext = segment.formatContext;
- segment.formatContext = getChildFormatContext(prevContext, type, props); // We use the non-destructive form because if something suspends, we still
- // need to pop back up and finish this subtree of HTML.
-
- renderNode(request, task, children); // We expect that errors will fatal the whole task and that we don't need
- // the correct context. Therefore this is not in a finally.
-
- segment.formatContext = prevContext;
- pushEndInstance(segment.chunks, request.postamble, type);
- segment.lastPushedText = false;
- popComponentStackInDEV(task);
-}
-
-function shouldConstruct$1(Component) {
- return Component.prototype && Component.prototype.isReactComponent;
-}
-
-function renderWithHooks(request, task, prevThenableState, Component, props, secondArg) {
- var componentIdentity = {};
- prepareToUseHooks(task, componentIdentity, prevThenableState);
- var result = Component(props, secondArg);
- return finishHooks(Component, props, result, secondArg);
-}
-
-function finishClassComponent(request, task, instance, Component, props) {
- var nextChildren = instance.render();
-
- {
- if (instance.props !== props) {
- if (!didWarnAboutReassigningProps) {
- error('It looks like %s is reassigning its own `this.props` while rendering. ' + 'This is not supported and can lead to confusing bugs.', getComponentNameFromType(Component) || 'a component');
- }
-
- didWarnAboutReassigningProps = true;
- }
- }
-
- {
- var childContextTypes = Component.childContextTypes;
-
- if (childContextTypes !== null && childContextTypes !== undefined) {
- var previousContext = task.legacyContext;
- var mergedContext = processChildContext(instance, Component, previousContext, childContextTypes);
- task.legacyContext = mergedContext;
- renderNodeDestructive(request, task, null, nextChildren);
- task.legacyContext = previousContext;
- return;
- }
- }
-
- renderNodeDestructive(request, task, null, nextChildren);
-}
-
-function renderClassComponent(request, task, Component, props) {
- pushClassComponentStackInDEV(task, Component);
- var maskedContext = getMaskedContext(Component, task.legacyContext) ;
- var instance = constructClassInstance(Component, props, maskedContext);
- mountClassInstance(instance, Component, props, maskedContext);
- finishClassComponent(request, task, instance, Component, props);
- popComponentStackInDEV(task);
-}
-
-var didWarnAboutBadClass = {};
-var didWarnAboutModulePatternComponent = {};
-var didWarnAboutContextTypeOnFunctionComponent = {};
-var didWarnAboutGetDerivedStateOnFunctionComponent = {};
-var didWarnAboutReassigningProps = false;
-var didWarnAboutDefaultPropsOnFunctionComponent = {};
-var didWarnAboutGenerators = false;
-var didWarnAboutMaps = false;
-var hasWarnedAboutUsingContextAsConsumer = false; // This would typically be a function component but we still support module pattern
-// components for some reason.
-
-function renderIndeterminateComponent(request, task, prevThenableState, Component, props) {
- var legacyContext;
-
- {
- legacyContext = getMaskedContext(Component, task.legacyContext);
- }
-
- pushFunctionComponentStackInDEV(task, Component);
-
- {
- if (Component.prototype && typeof Component.prototype.render === 'function') {
- var componentName = getComponentNameFromType(Component) || 'Unknown';
-
- if (!didWarnAboutBadClass[componentName]) {
- error("The <%s /> component appears to have a render method, but doesn't extend React.Component. " + 'This is likely to cause errors. Change %s to extend React.Component instead.', componentName, componentName);
-
- didWarnAboutBadClass[componentName] = true;
- }
- }
- }
-
- var value = renderWithHooks(request, task, prevThenableState, Component, props, legacyContext);
- var hasId = checkDidRenderIdHook();
-
- {
- // Support for module components is deprecated and is removed behind a flag.
- // Whether or not it would crash later, we want to show a good message in DEV first.
- if (typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
- var _componentName = getComponentNameFromType(Component) || 'Unknown';
-
- if (!didWarnAboutModulePatternComponent[_componentName]) {
- error('The <%s /> component appears to be a function component that returns a class instance. ' + 'Change %s to a class that extends React.Component instead. ' + "If you can't use a class try assigning the prototype on the function as a workaround. " + "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " + 'cannot be called with `new` by React.', _componentName, _componentName, _componentName);
-
- didWarnAboutModulePatternComponent[_componentName] = true;
- }
- }
- }
-
- if ( // Run these checks in production only if the flag is off.
- // Eventually we'll delete this branch altogether.
- typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {
- {
- var _componentName2 = getComponentNameFromType(Component) || 'Unknown';
-
- if (!didWarnAboutModulePatternComponent[_componentName2]) {
- error('The <%s /> component appears to be a function component that returns a class instance. ' + 'Change %s to a class that extends React.Component instead. ' + "If you can't use a class try assigning the prototype on the function as a workaround. " + "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " + 'cannot be called with `new` by React.', _componentName2, _componentName2, _componentName2);
-
- didWarnAboutModulePatternComponent[_componentName2] = true;
- }
- }
-
- mountClassInstance(value, Component, props, legacyContext);
- finishClassComponent(request, task, value, Component, props);
- } else {
-
- {
- validateFunctionComponentInDev(Component);
- } // We're now successfully past this task, and we don't have to pop back to
- // the previous task every again, so we can use the destructive recursive form.
-
-
- if (hasId) {
- // This component materialized an id. We treat this as its own level, with
- // a single "child" slot.
- var prevTreeContext = task.treeContext;
- var totalChildren = 1;
- var index = 0;
- task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
-
- try {
- renderNodeDestructive(request, task, null, value);
- } finally {
- task.treeContext = prevTreeContext;
- }
- } else {
- renderNodeDestructive(request, task, null, value);
- }
- }
-
- popComponentStackInDEV(task);
-}
-
-function validateFunctionComponentInDev(Component) {
- {
- if (Component) {
- if (Component.childContextTypes) {
- error('%s(...): childContextTypes cannot be defined on a function component.', Component.displayName || Component.name || 'Component');
- }
- }
-
- if ( Component.defaultProps !== undefined) {
- var componentName = getComponentNameFromType(Component) || 'Unknown';
-
- if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
- error('%s: Support for defaultProps will be removed from function components ' + 'in a future major release. Use JavaScript default parameters instead.', componentName);
-
- didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
- }
- }
-
- if (typeof Component.getDerivedStateFromProps === 'function') {
- var _componentName3 = getComponentNameFromType(Component) || 'Unknown';
-
- if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
- error('%s: Function components do not support getDerivedStateFromProps.', _componentName3);
-
- didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
- }
- }
-
- if (typeof Component.contextType === 'object' && Component.contextType !== null) {
- var _componentName4 = getComponentNameFromType(Component) || 'Unknown';
-
- if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
- error('%s: Function components do not support contextType.', _componentName4);
-
- didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
- }
- }
- }
-}
-
-function resolveDefaultProps(Component, baseProps) {
- if (Component && Component.defaultProps) {
- // Resolve default props. Taken from ReactElement
- var props = assign({}, baseProps);
- var defaultProps = Component.defaultProps;
-
- for (var propName in defaultProps) {
- if (props[propName] === undefined) {
- props[propName] = defaultProps[propName];
- }
- }
-
- return props;
- }
-
- return baseProps;
-}
-
-function renderForwardRef(request, task, prevThenableState, type, props, ref) {
- pushFunctionComponentStackInDEV(task, type.render);
- var children = renderWithHooks(request, task, prevThenableState, type.render, props, ref);
- var hasId = checkDidRenderIdHook();
-
- if (hasId) {
- // This component materialized an id. We treat this as its own level, with
- // a single "child" slot.
- var prevTreeContext = task.treeContext;
- var totalChildren = 1;
- var index = 0;
- task.treeContext = pushTreeContext(prevTreeContext, totalChildren, index);
-
- try {
- renderNodeDestructive(request, task, null, children);
- } finally {
- task.treeContext = prevTreeContext;
- }
- } else {
- renderNodeDestructive(request, task, null, children);
- }
-
- popComponentStackInDEV(task);
-}
-
-function renderMemo(request, task, prevThenableState, type, props, ref) {
- var innerType = type.type;
- var resolvedProps = resolveDefaultProps(innerType, props);
- renderElement(request, task, prevThenableState, innerType, resolvedProps, ref);
-}
-
-function renderContextConsumer(request, task, context, props) {
- // The logic below for Context differs depending on PROD or DEV mode. In
- // DEV mode, we create a separate object for Context.Consumer that acts
- // like a proxy to Context. This proxy object adds unnecessary code in PROD
- // so we use the old behaviour (Context.Consumer references Context) to
- // reduce size and overhead. The separate object references context via
- // a property called "_context", which also gives us the ability to check
- // in DEV mode if this property exists or not and warn if it does not.
- {
- if (context._context === undefined) {
- // This may be because it's a Context (rather than a Consumer).
- // Or it may be because it's older React where they're the same thing.
- // We only want to warn if we're sure it's a new React.
- if (context !== context.Consumer) {
- if (!hasWarnedAboutUsingContextAsConsumer) {
- hasWarnedAboutUsingContextAsConsumer = true;
-
- error('Rendering directly is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
- }
- }
- } else {
- context = context._context;
- }
- }
-
- var render = props.children;
-
- {
- if (typeof render !== 'function') {
- error('A context consumer was rendered with multiple children, or a child ' + "that isn't a function. A context consumer expects a single child " + 'that is a function. If you did pass a function, make sure there ' + 'is no trailing or leading whitespace around it.');
- }
- }
-
- var newValue = readContext(context);
- var newChildren = render(newValue);
- renderNodeDestructive(request, task, null, newChildren);
-}
-
-function renderContextProvider(request, task, type, props) {
- var context = type._context;
- var value = props.value;
- var children = props.children;
- var prevSnapshot;
-
- {
- prevSnapshot = task.context;
- }
-
- task.context = pushProvider(context, value);
- renderNodeDestructive(request, task, null, children);
- task.context = popProvider(context);
-
- {
- if (prevSnapshot !== task.context) {
- error('Popping the context provider did not return back to the original snapshot. This is a bug in React.');
- }
- }
-}
-
-function renderLazyComponent(request, task, prevThenableState, lazyComponent, props, ref) {
- pushBuiltInComponentStackInDEV(task, 'Lazy');
- var payload = lazyComponent._payload;
- var init = lazyComponent._init;
- var Component = init(payload);
- var resolvedProps = resolveDefaultProps(Component, props);
- renderElement(request, task, prevThenableState, Component, resolvedProps, ref);
- popComponentStackInDEV(task);
-}
-
-function renderOffscreen(request, task, props) {
- var mode = props.mode;
-
- if (mode === 'hidden') ; else {
- // A visible Offscreen boundary is treated exactly like a fragment: a
- // pure indirection.
- renderNodeDestructive(request, task, null, props.children);
- }
-}
-
-function renderElement(request, task, prevThenableState, type, props, ref) {
- if (typeof type === 'function') {
- if (shouldConstruct$1(type)) {
- renderClassComponent(request, task, type, props);
- return;
- } else {
- renderIndeterminateComponent(request, task, prevThenableState, type, props);
- return;
- }
- }
-
- if (typeof type === 'string') {
- renderHostElement(request, task, type, props);
- return;
- }
-
- switch (type) {
- // LegacyHidden acts the same as a fragment. This only works because we
- // currently assume that every instance of LegacyHidden is accompanied by a
- // host component wrapper. In the hidden mode, the host component is given a
- // `hidden` attribute, which ensures that the initial HTML is not visible.
- // To support the use of LegacyHidden as a true fragment, without an extra
- // DOM node, we would have to hide the initial HTML in some other way.
- // TODO: Delete in LegacyHidden. It's an unstable API only used in the
- // www build. As a migration step, we could add a special prop to Offscreen
- // that simulates the old behavior (no hiding, no change to effects).
- case REACT_LEGACY_HIDDEN_TYPE:
- case REACT_DEBUG_TRACING_MODE_TYPE:
- case REACT_STRICT_MODE_TYPE:
- case REACT_PROFILER_TYPE:
- case REACT_FRAGMENT_TYPE:
- {
- renderNodeDestructive(request, task, null, props.children);
- return;
- }
-
- case REACT_OFFSCREEN_TYPE:
- {
- renderOffscreen(request, task, props);
- return;
- }
-
- case REACT_SUSPENSE_LIST_TYPE:
- {
- pushBuiltInComponentStackInDEV(task, 'SuspenseList'); // TODO: SuspenseList should control the boundaries.
-
- renderNodeDestructive(request, task, null, props.children);
- popComponentStackInDEV(task);
- return;
- }
-
- case REACT_SCOPE_TYPE:
- {
-
- throw new Error('ReactDOMServer does not yet support scope components.');
- }
- // eslint-disable-next-line-no-fallthrough
-
- case REACT_SUSPENSE_TYPE:
- {
- {
- renderSuspenseBoundary(request, task, props);
- }
-
- return;
- }
- }
-
- if (typeof type === 'object' && type !== null) {
- switch (type.$$typeof) {
- case REACT_FORWARD_REF_TYPE:
- {
- renderForwardRef(request, task, prevThenableState, type, props, ref);
- return;
- }
-
- case REACT_MEMO_TYPE:
- {
- renderMemo(request, task, prevThenableState, type, props, ref);
- return;
- }
-
- case REACT_PROVIDER_TYPE:
- {
- renderContextProvider(request, task, type, props);
- return;
- }
-
- case REACT_CONTEXT_TYPE:
- {
- renderContextConsumer(request, task, type, props);
- return;
- }
-
- case REACT_LAZY_TYPE:
- {
- renderLazyComponent(request, task, prevThenableState, type, props);
- return;
- }
- }
- }
-
- var info = '';
-
- {
- if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
- info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and " + 'named imports.';
- }
- }
-
- throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
-}
-
-function validateIterable(iterable, iteratorFn) {
- {
- // We don't support rendering Generators because it's a mutation.
- // See https://github.com/facebook/react/issues/12995
- if (typeof Symbol === 'function' && // $FlowFixMe Flow doesn't know about toStringTag
- iterable[Symbol.toStringTag] === 'Generator') {
- if (!didWarnAboutGenerators) {
- error('Using Generators as children is unsupported and will likely yield ' + 'unexpected results because enumerating a generator mutates it. ' + 'You may convert it to an array with `Array.from()` or the ' + '`[...spread]` operator before rendering. Keep in mind ' + 'you might need to polyfill these features for older browsers.');
- }
-
- didWarnAboutGenerators = true;
- } // Warn about using Maps as children
-
-
- if (iterable.entries === iteratorFn) {
- if (!didWarnAboutMaps) {
- error('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.');
- }
-
- didWarnAboutMaps = true;
- }
- }
-}
-
-function renderNodeDestructive(request, task, // The thenable state reused from the previous attempt, if any. This is almost
-// always null, except when called by retryTask.
-prevThenableState, node) {
- {
- // In Dev we wrap renderNodeDestructiveImpl in a try / catch so we can capture
- // a component stack at the right place in the tree. We don't do this in renderNode
- // becuase it is not called at every layer of the tree and we may lose frames
- try {
- return renderNodeDestructiveImpl(request, task, prevThenableState, node);
- } catch (x) {
- if (typeof x === 'object' && x !== null && typeof x.then === 'function') ; else {
- // This is an error, stash the component stack if it is null.
- lastBoundaryErrorComponentStackDev = lastBoundaryErrorComponentStackDev !== null ? lastBoundaryErrorComponentStackDev : getCurrentStackInDEV();
- } // rethrow so normal suspense logic can handle thrown value accordingly
-
-
- throw x;
- }
- }
-} // This function by it self renders a node and consumes the task by mutating it
-// to update the current execution state.
-
-
-function renderNodeDestructiveImpl(request, task, prevThenableState, node) {
- // Stash the node we're working on. We'll pick up from this task in case
- // something suspends.
- task.node = node; // Handle object types
-
- if (typeof node === 'object' && node !== null) {
- switch (node.$$typeof) {
- case REACT_ELEMENT_TYPE:
- {
- var element = node;
- var type = element.type;
- var props = element.props;
- var ref = element.ref;
- renderElement(request, task, prevThenableState, type, props, ref);
- return;
- }
-
- case REACT_PORTAL_TYPE:
- throw new Error('Portals are not currently supported by the server renderer. ' + 'Render them conditionally so that they only appear on the client render.');
- // eslint-disable-next-line-no-fallthrough
-
- case REACT_LAZY_TYPE:
- {
- var lazyNode = node;
- var payload = lazyNode._payload;
- var init = lazyNode._init;
- var resolvedNode;
-
- {
- try {
- resolvedNode = init(payload);
- } catch (x) {
- if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
- // this Lazy initializer is suspending. push a temporary frame onto the stack so it can be
- // popped off in spawnNewSuspendedTask. This aligns stack behavior between Lazy in element position
- // vs Component position. We do not want the frame for Errors so we exclusively do this in
- // the wakeable branch
- pushBuiltInComponentStackInDEV(task, 'Lazy');
- }
-
- throw x;
- }
- }
-
- renderNodeDestructive(request, task, null, resolvedNode);
- return;
- }
- }
-
- if (isArray(node)) {
- renderChildrenArray(request, task, node);
- return;
- }
-
- var iteratorFn = getIteratorFn(node);
-
- if (iteratorFn) {
- {
- validateIterable(node, iteratorFn);
- }
-
- var iterator = iteratorFn.call(node);
-
- if (iterator) {
- // We need to know how many total children are in this set, so that we
- // can allocate enough id slots to acommodate them. So we must exhaust
- // the iterator before we start recursively rendering the children.
- // TODO: This is not great but I think it's inherent to the id
- // generation algorithm.
- var step = iterator.next(); // If there are not entries, we need to push an empty so we start by checking that.
-
- if (!step.done) {
- var children = [];
-
- do {
- children.push(step.value);
- step = iterator.next();
- } while (!step.done);
-
- renderChildrenArray(request, task, children);
- return;
- }
-
- return;
- }
- } // $FlowFixMe[method-unbinding]
-
-
- var childString = Object.prototype.toString.call(node);
- throw new Error("Objects are not valid as a React child (found: " + (childString === '[object Object]' ? 'object with keys {' + Object.keys(node).join(', ') + '}' : childString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
- }
-
- if (typeof node === 'string') {
- var segment = task.blockedSegment;
- segment.lastPushedText = pushTextInstance(task.blockedSegment.chunks, node, request.responseState, segment.lastPushedText);
- return;
- }
-
- if (typeof node === 'number') {
- var _segment = task.blockedSegment;
- _segment.lastPushedText = pushTextInstance(task.blockedSegment.chunks, '' + node, request.responseState, _segment.lastPushedText);
- return;
- }
-
- {
- if (typeof node === 'function') {
- error('Functions are not valid as a React child. This may happen if ' + 'you return a Component instead of from render. ' + 'Or maybe you meant to call this function rather than return it.');
- }
- }
-}
-
-function renderChildrenArray(request, task, children) {
- var totalChildren = children.length;
-
- for (var i = 0; i < totalChildren; i++) {
- var prevTreeContext = task.treeContext;
- task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i);
-
- try {
- // We need to use the non-destructive form so that we can safely pop back
- // up and render the sibling if something suspends.
- renderNode(request, task, children[i]);
- } finally {
- task.treeContext = prevTreeContext;
- }
- }
-}
-
-function spawnNewSuspendedTask(request, task, thenableState, x) {
- // Something suspended, we'll need to create a new segment and resolve it later.
- var segment = task.blockedSegment;
- var insertionIndex = segment.chunks.length;
- var newSegment = createPendingSegment(request, insertionIndex, null, segment.formatContext, // Adopt the parent segment's leading text embed
- segment.lastPushedText, // Assume we are text embedded at the trailing edge
- true);
- segment.children.push(newSegment); // Reset lastPushedText for current Segment since the new Segment "consumed" it
-
- segment.lastPushedText = false;
- var newTask = createTask(request, thenableState, task.node, task.blockedBoundary, newSegment, task.abortSet, task.legacyContext, task.context, task.treeContext);
-
- {
- if (task.componentStack !== null) {
- // We pop one task off the stack because the node that suspended will be tried again,
- // which will add it back onto the stack.
- newTask.componentStack = task.componentStack.parent;
- }
- }
-
- var ping = newTask.ping;
- x.then(ping, ping);
-} // This is a non-destructive form of rendering a node. If it suspends it spawns
-// a new task and restores the context of this task to what it was before.
-
-
-function renderNode(request, task, node) {
- // TODO: Store segment.children.length here and reset it in case something
- // suspended partially through writing something.
- // Snapshot the current context in case something throws to interrupt the
- // process.
- var previousFormatContext = task.blockedSegment.formatContext;
- var previousLegacyContext = task.legacyContext;
- var previousContext = task.context;
- var previousComponentStack = null;
-
- {
- previousComponentStack = task.componentStack;
- }
-
- try {
- return renderNodeDestructive(request, task, null, node);
- } catch (thrownValue) {
- resetHooksState();
- var x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
- // reasons, the rest of the Suspense implementation expects the thrown
- // value to be a thenable, because before `use` existed that was the
- // (unstable) API for suspending. This implementation detail can change
- // later, once we deprecate the old API in favor of `use`.
- getSuspendedThenable() : thrownValue; // $FlowFixMe[method-unbinding]
-
- if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
- var wakeable = x;
- var thenableState = getThenableStateAfterSuspending();
- spawnNewSuspendedTask(request, task, thenableState, wakeable); // Restore the context. We assume that this will be restored by the inner
- // functions in case nothing throws so we don't use "finally" here.
-
- task.blockedSegment.formatContext = previousFormatContext;
- task.legacyContext = previousLegacyContext;
- task.context = previousContext; // Restore all active ReactContexts to what they were before.
-
- switchContext(previousContext);
-
- {
- task.componentStack = previousComponentStack;
- }
-
- return;
- } else {
- // Restore the context. We assume that this will be restored by the inner
- // functions in case nothing throws so we don't use "finally" here.
- task.blockedSegment.formatContext = previousFormatContext;
- task.legacyContext = previousLegacyContext;
- task.context = previousContext; // Restore all active ReactContexts to what they were before.
-
- switchContext(previousContext);
-
- {
- task.componentStack = previousComponentStack;
- } // We assume that we don't need the correct context.
- // Let's terminate the rest of the tree and don't render any siblings.
-
-
- throw x;
- }
- }
-}
-
-function erroredTask(request, boundary, segment, error) {
- // Report the error to a global handler.
- var errorDigest = logRecoverableError(request, error);
-
- if (boundary === null) {
- fatalError(request, error);
- } else {
- boundary.pendingTasks--;
-
- if (!boundary.forceClientRender) {
- boundary.forceClientRender = true;
- boundary.errorDigest = errorDigest;
-
- {
- captureBoundaryErrorDetailsDev(boundary, error);
- } // Regardless of what happens next, this boundary won't be displayed,
- // so we can flush it, if the parent already flushed.
-
-
- if (boundary.parentFlushed) {
- // We don't have a preference where in the queue this goes since it's likely
- // to error on the client anyway. However, intentionally client-rendered
- // boundaries should be flushed earlier so that they can start on the client.
- // We reuse the same queue for errors.
- request.clientRenderedBoundaries.push(boundary);
- }
- }
- }
-
- request.allPendingTasks--;
-
- if (request.allPendingTasks === 0) {
- var onAllReady = request.onAllReady;
- onAllReady();
- }
-}
-
-function abortTaskSoft(task) {
- // This aborts task without aborting the parent boundary that it blocks.
- // It's used for when we didn't need this task to complete the tree.
- // If task was needed, then it should use abortTask instead.
- var request = this;
- var boundary = task.blockedBoundary;
- var segment = task.blockedSegment;
- segment.status = ABORTED;
- finishedTask(request, boundary, segment);
-}
-
-function abortTask(task, request, error) {
- // This aborts the task and aborts the parent that it blocks, putting it into
- // client rendered mode.
- var boundary = task.blockedBoundary;
- var segment = task.blockedSegment;
- segment.status = ABORTED;
-
- if (boundary === null) {
- request.allPendingTasks--; // We didn't complete the root so we have nothing to show. We can close
- // the request;
-
- if (request.status !== CLOSING && request.status !== CLOSED) {
- logRecoverableError(request, error);
- fatalError(request, error);
- }
- } else {
- boundary.pendingTasks--;
-
- if (!boundary.forceClientRender) {
- boundary.forceClientRender = true;
- boundary.errorDigest = request.onError(error);
-
- {
- var errorPrefix = 'The server did not finish this Suspense boundary: ';
- var errorMessage;
-
- if (error && typeof error.message === 'string') {
- errorMessage = errorPrefix + error.message;
- } else {
- // eslint-disable-next-line react-internal/safe-string-coercion
- errorMessage = errorPrefix + String(error);
- }
-
- var previousTaskInDev = currentTaskInDEV;
- currentTaskInDEV = task;
-
- try {
- captureBoundaryErrorDetailsDev(boundary, errorMessage);
- } finally {
- currentTaskInDEV = previousTaskInDev;
- }
- }
-
- if (boundary.parentFlushed) {
- request.clientRenderedBoundaries.push(boundary);
- }
- } // If this boundary was still pending then we haven't already cancelled its fallbacks.
- // We'll need to abort the fallbacks, which will also error that parent boundary.
-
-
- boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
- return abortTask(fallbackTask, request, error);
- });
- boundary.fallbackAbortableTasks.clear();
- request.allPendingTasks--;
-
- if (request.allPendingTasks === 0) {
- var onAllReady = request.onAllReady;
- onAllReady();
- }
- }
-}
-
-function queueCompletedSegment(boundary, segment) {
- if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
- // This is an empty segment. There's nothing to write, so we can instead transfer the ID
- // to the child. That way any existing references point to the child.
- var childSegment = segment.children[0];
- childSegment.id = segment.id;
- childSegment.parentFlushed = true;
-
- if (childSegment.status === COMPLETED) {
- queueCompletedSegment(boundary, childSegment);
- }
- } else {
- var completedSegments = boundary.completedSegments;
- completedSegments.push(segment);
- }
-}
-
-function finishedTask(request, boundary, segment) {
- if (boundary === null) {
- if (segment.parentFlushed) {
- if (request.completedRootSegment !== null) {
- throw new Error('There can only be one root segment. This is a bug in React.');
- }
-
- request.completedRootSegment = segment;
- }
-
- request.pendingRootTasks--;
-
- if (request.pendingRootTasks === 0) {
- // We have completed the shell so the shell can't error anymore.
- request.onShellError = noop$2;
- var onShellReady = request.onShellReady;
- onShellReady();
- }
- } else {
- boundary.pendingTasks--;
-
- if (boundary.forceClientRender) ; else if (boundary.pendingTasks === 0) {
- // This must have been the last segment we were waiting on. This boundary is now complete.
- if (segment.parentFlushed) {
- // Our parent segment already flushed, so we need to schedule this segment to be emitted.
- // If it is a segment that was aborted, we'll write other content instead so we don't need
- // to emit it.
- if (segment.status === COMPLETED) {
- queueCompletedSegment(boundary, segment);
- }
- }
-
- {
- hoistCompletedBoundaryResources(request, boundary);
- }
-
- if (boundary.parentFlushed) {
- // The segment might be part of a segment that didn't flush yet, but if the boundary's
- // parent flushed, we need to schedule the boundary to be emitted.
- request.completedBoundaries.push(boundary);
- } // We can now cancel any pending task on the fallback since we won't need to show it anymore.
- // This needs to happen after we read the parentFlushed flags because aborting can finish
- // work which can trigger user code, which can start flushing, which can change those flags.
-
-
- boundary.fallbackAbortableTasks.forEach(abortTaskSoft, request);
- boundary.fallbackAbortableTasks.clear();
- } else {
- if (segment.parentFlushed) {
- // Our parent already flushed, so we need to schedule this segment to be emitted.
- // If it is a segment that was aborted, we'll write other content instead so we don't need
- // to emit it.
- if (segment.status === COMPLETED) {
- queueCompletedSegment(boundary, segment);
- var completedSegments = boundary.completedSegments;
-
- if (completedSegments.length === 1) {
- // This is the first time since we last flushed that we completed anything.
- // We can schedule this boundary to emit its partially completed segments early
- // in case the parent has already been flushed.
- if (boundary.parentFlushed) {
- request.partialBoundaries.push(boundary);
- }
- }
- }
- }
- }
- }
-
- request.allPendingTasks--;
-
- if (request.allPendingTasks === 0) {
- // This needs to be called at the very end so that we can synchronously write the result
- // in the callback if needed.
- var onAllReady = request.onAllReady;
- onAllReady();
- }
-}
-
-function retryTask(request, task) {
- {
- var blockedBoundary = task.blockedBoundary;
- setCurrentlyRenderingBoundaryResourcesTarget(request.resources, blockedBoundary ? blockedBoundary.resources : null);
- }
-
- var segment = task.blockedSegment;
-
- if (segment.status !== PENDING) {
- // We completed this by other means before we had a chance to retry it.
- return;
- } // We restore the context to what it was when we suspended.
- // We don't restore it after we leave because it's likely that we'll end up
- // needing a very similar context soon again.
-
-
- switchContext(task.context);
- var prevTaskInDEV = null;
-
- {
- prevTaskInDEV = currentTaskInDEV;
- currentTaskInDEV = task;
- }
-
- try {
- // We call the destructive form that mutates this task. That way if something
- // suspends again, we can reuse the same task instead of spawning a new one.
- // Reset the task's thenable state before continuing, so that if a later
- // component suspends we can reuse the same task object. If the same
- // component suspends again, the thenable state will be restored.
- var prevThenableState = task.thenableState;
- task.thenableState = null;
- renderNodeDestructive(request, task, prevThenableState, task.node);
- pushSegmentFinale(segment.chunks, request.responseState, segment.lastPushedText, segment.textEmbedded);
- task.abortSet.delete(task);
- segment.status = COMPLETED;
- finishedTask(request, task.blockedBoundary, segment);
- } catch (thrownValue) {
- resetHooksState();
- var x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
- // reasons, the rest of the Suspense implementation expects the thrown
- // value to be a thenable, because before `use` existed that was the
- // (unstable) API for suspending. This implementation detail can change
- // later, once we deprecate the old API in favor of `use`.
- getSuspendedThenable() : thrownValue; // $FlowFixMe[method-unbinding]
-
- if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
- // Something suspended again, let's pick it back up later.
- var ping = task.ping;
- x.then(ping, ping);
- task.thenableState = getThenableStateAfterSuspending();
- } else {
- task.abortSet.delete(task);
- segment.status = ERRORED;
- erroredTask(request, task.blockedBoundary, segment, x);
- }
- } finally {
- {
- setCurrentlyRenderingBoundaryResourcesTarget(request.resources, null);
- }
-
- {
- currentTaskInDEV = prevTaskInDEV;
- }
- }
-}
-
-function performWork(request) {
- if (request.status === CLOSED) {
- return;
- }
-
- var prevContext = getActiveContext();
- var prevDispatcher = ReactCurrentDispatcher$1.current;
- ReactCurrentDispatcher$1.current = HooksDispatcher;
- var prevCacheDispatcher;
-
- {
- prevCacheDispatcher = ReactCurrentCache.current;
- ReactCurrentCache.current = DefaultCacheDispatcher;
- }
-
- var previousHostDispatcher = prepareToRender(request.resources);
- var prevGetCurrentStackImpl;
-
- {
- prevGetCurrentStackImpl = ReactDebugCurrentFrame$1.getCurrentStack;
- ReactDebugCurrentFrame$1.getCurrentStack = getCurrentStackInDEV;
- }
-
- var prevResponseState = currentResponseState;
- setCurrentResponseState(request.responseState);
-
- try {
- var pingedTasks = request.pingedTasks;
- var i;
-
- for (i = 0; i < pingedTasks.length; i++) {
- var task = pingedTasks[i];
- retryTask(request, task);
- }
-
- pingedTasks.splice(0, i);
-
- if (request.destination !== null) {
- flushCompletedQueues(request, request.destination);
- }
- } catch (error) {
- logRecoverableError(request, error);
- fatalError(request, error);
- } finally {
- setCurrentResponseState(prevResponseState);
- ReactCurrentDispatcher$1.current = prevDispatcher;
-
- {
- ReactCurrentCache.current = prevCacheDispatcher;
- }
-
- cleanupAfterRender(previousHostDispatcher);
-
- {
- ReactDebugCurrentFrame$1.getCurrentStack = prevGetCurrentStackImpl;
- }
-
- if (prevDispatcher === HooksDispatcher) {
- // This means that we were in a reentrant work loop. This could happen
- // in a renderer that supports synchronous work like renderToString,
- // when it's called from within another renderer.
- // Normally we don't bother switching the contexts to their root/default
- // values when leaving because we'll likely need the same or similar
- // context again. However, when we're inside a synchronous loop like this
- // we'll to restore the context to what it was before returning.
- switchContext(prevContext);
- }
- }
-}
-
-function flushSubtree(request, destination, segment) {
- segment.parentFlushed = true;
-
- switch (segment.status) {
- case PENDING:
- {
- // We're emitting a placeholder for this segment to be filled in later.
- // Therefore we'll need to assign it an ID - to refer to it by.
- var segmentID = segment.id = request.nextSegmentId++; // When this segment finally completes it won't be embedded in text since it will flush separately
-
- segment.lastPushedText = false;
- segment.textEmbedded = false;
- return writePlaceholder(destination, request.responseState, segmentID);
- }
-
- case COMPLETED:
- {
- segment.status = FLUSHED;
- var r = true;
- var chunks = segment.chunks;
- var chunkIdx = 0;
- var children = segment.children;
-
- for (var childIdx = 0; childIdx < children.length; childIdx++) {
- var nextChild = children[childIdx]; // Write all the chunks up until the next child.
-
- for (; chunkIdx < nextChild.index; chunkIdx++) {
- writeChunk(destination, chunks[chunkIdx]);
- }
-
- r = flushSegment(request, destination, nextChild);
- } // Finally just write all the remaining chunks
-
-
- for (; chunkIdx < chunks.length - 1; chunkIdx++) {
- writeChunk(destination, chunks[chunkIdx]);
- }
-
- if (chunkIdx < chunks.length) {
- r = writeChunkAndReturn(destination, chunks[chunkIdx]);
- }
-
- return r;
- }
-
- default:
- {
- throw new Error('Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.');
- }
- }
-}
-
-function flushSegment(request, destination, segment) {
- var boundary = segment.boundary;
-
- if (boundary === null) {
- // Not a suspense boundary.
- return flushSubtree(request, destination, segment);
- }
-
- boundary.parentFlushed = true; // This segment is a Suspense boundary. We need to decide whether to
- // emit the content or the fallback now.
-
- if (boundary.forceClientRender) {
- // Emit a client rendered suspense boundary wrapper.
- // We never queue the inner boundary so we'll never emit its content or partial segments.
- writeStartClientRenderedSuspenseBoundary(destination, request.responseState, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack); // Flush the fallback.
-
- flushSubtree(request, destination, segment);
- return writeEndClientRenderedSuspenseBoundary(destination, request.responseState);
- } else if (boundary.pendingTasks > 0) {
- // This boundary is still loading. Emit a pending suspense boundary wrapper.
- // Assign an ID to refer to the future content by.
- boundary.rootSegmentID = request.nextSegmentId++;
-
- if (boundary.completedSegments.length > 0) {
- // If this is at least partially complete, we can queue it to be partially emitted early.
- request.partialBoundaries.push(boundary);
- } /// This is the first time we should have referenced this ID.
-
-
- var id = boundary.id = assignSuspenseBoundaryID(request.responseState);
- writeStartPendingSuspenseBoundary(destination, request.responseState, id); // Flush the fallback.
-
- flushSubtree(request, destination, segment);
- return writeEndPendingSuspenseBoundary(destination, request.responseState);
- } else if (boundary.byteSize > request.progressiveChunkSize) {
- // This boundary is large and will be emitted separately so that we can progressively show
- // other content. We add it to the queue during the flush because we have to ensure that
- // the parent flushes first so that there's something to inject it into.
- // We also have to make sure that it's emitted into the queue in a deterministic slot.
- // I.e. we can't insert it here when it completes.
- // Assign an ID to refer to the future content by.
- boundary.rootSegmentID = request.nextSegmentId++;
- request.completedBoundaries.push(boundary); // Emit a pending rendered suspense boundary wrapper.
-
- writeStartPendingSuspenseBoundary(destination, request.responseState, boundary.id); // Flush the fallback.
-
- flushSubtree(request, destination, segment);
- return writeEndPendingSuspenseBoundary(destination, request.responseState);
- } else {
- {
- hoistResources(request.resources, boundary.resources);
- } // We can inline this boundary's content as a complete boundary.
-
-
- writeStartCompletedSuspenseBoundary(destination, request.responseState);
- var completedSegments = boundary.completedSegments;
-
- if (completedSegments.length !== 1) {
- throw new Error('A previously unvisited boundary must have exactly one root segment. This is a bug in React.');
- }
-
- var contentSegment = completedSegments[0];
- flushSegment(request, destination, contentSegment);
- return writeEndCompletedSuspenseBoundary(destination, request.responseState);
- }
-}
-
-function flushInitialResources(destination, resources, responseState) {
- writeInitialResources(destination, resources, responseState);
-}
-
-function flushImmediateResources(destination, request) {
- writeImmediateResources(destination, request.resources, request.responseState);
-}
-
-function flushClientRenderedBoundary(request, destination, boundary) {
- return writeClientRenderBoundaryInstruction(destination, request.responseState, boundary.id, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
-}
-
-function flushSegmentContainer(request, destination, segment) {
- writeStartSegment(destination, request.responseState, segment.formatContext, segment.id);
- flushSegment(request, destination, segment);
- return writeEndSegment(destination, segment.formatContext);
-}
-
-function flushCompletedBoundary(request, destination, boundary) {
- {
- setCurrentlyRenderingBoundaryResourcesTarget(request.resources, boundary.resources);
- }
-
- var completedSegments = boundary.completedSegments;
- var i = 0;
-
- for (; i < completedSegments.length; i++) {
- var segment = completedSegments[i];
- flushPartiallyCompletedSegment(request, destination, boundary, segment);
- }
-
- completedSegments.length = 0;
- return writeCompletedBoundaryInstruction(destination, request.responseState, boundary.id, boundary.rootSegmentID, boundary.resources);
-}
-
-function flushPartialBoundary(request, destination, boundary) {
- {
- setCurrentlyRenderingBoundaryResourcesTarget(request.resources, boundary.resources);
- }
-
- var completedSegments = boundary.completedSegments;
- var i = 0;
-
- for (; i < completedSegments.length; i++) {
- var segment = completedSegments[i];
-
- if (!flushPartiallyCompletedSegment(request, destination, boundary, segment)) {
- i++;
- completedSegments.splice(0, i); // Only write as much as the buffer wants. Something higher priority
- // might want to write later.
-
- return false;
- }
- }
-
- completedSegments.splice(0, i);
- return true;
-}
-
-function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
- if (segment.status === FLUSHED) {
- // We've already flushed this inline.
- return true;
- }
-
- var segmentID = segment.id;
-
- if (segmentID === -1) {
- // This segment wasn't previously referred to. This happens at the root of
- // a boundary. We make kind of a leap here and assume this is the root.
- var rootSegmentID = segment.id = boundary.rootSegmentID;
-
- if (rootSegmentID === -1) {
- throw new Error('A root segment ID must have been assigned by now. This is a bug in React.');
- }
-
- return flushSegmentContainer(request, destination, segment);
- } else {
- flushSegmentContainer(request, destination, segment);
- return writeCompletedSegmentInstruction(destination, request.responseState, segmentID);
- }
-}
-
-function flushCompletedQueues(request, destination) {
-
- try {
- // The structure of this is to go through each queue one by one and write
- // until the sink tells us to stop. When we should stop, we still finish writing
- // that item fully and then yield. At that point we remove the already completed
- // items up until the point we completed them.
- var i;
- var completedRootSegment = request.completedRootSegment;
-
- if (completedRootSegment !== null) {
- if (request.pendingRootTasks === 0) {
- if (enableFloat) {
- var preamble = request.preamble;
-
- for (i = 0; i < preamble.length; i++) {
- // we expect the preamble to be tiny and will ignore backpressure
- writeChunk(destination, preamble[i]);
- }
-
- flushInitialResources(destination, request.resources, request.responseState);
- }
-
- flushSegment(request, destination, completedRootSegment);
- request.completedRootSegment = null;
- writeCompletedRoot(destination, request.responseState);
- } else {
- // We haven't flushed the root yet so we don't need to check any other branches further down
- return;
- }
- } else if (enableFloat) {
- flushImmediateResources(destination, request);
- } // We emit client rendering instructions for already emitted boundaries first.
- // This is so that we can signal to the client to start client rendering them as
- // soon as possible.
-
-
- var clientRenderedBoundaries = request.clientRenderedBoundaries;
-
- for (i = 0; i < clientRenderedBoundaries.length; i++) {
- var boundary = clientRenderedBoundaries[i];
-
- if (!flushClientRenderedBoundary(request, destination, boundary)) {
- request.destination = null;
- i++;
- clientRenderedBoundaries.splice(0, i);
- return;
- }
- }
-
- clientRenderedBoundaries.splice(0, i); // Next we emit any complete boundaries. It's better to favor boundaries
- // that are completely done since we can actually show them, than it is to emit
- // any individual segments from a partially complete boundary.
-
- var completedBoundaries = request.completedBoundaries;
-
- for (i = 0; i < completedBoundaries.length; i++) {
- var _boundary = completedBoundaries[i];
-
- if (!flushCompletedBoundary(request, destination, _boundary)) {
- request.destination = null;
- i++;
- completedBoundaries.splice(0, i);
- return;
- }
- }
-
- completedBoundaries.splice(0, i); // Allow anything written so far to flush to the underlying sink before
- // we continue with lower priorities.
-
- completeWriting(destination);
- beginWriting(destination); // TODO: Here we'll emit data used by hydration.
- // Next we emit any segments of any boundaries that are partially complete
- // but not deeply complete.
-
- var partialBoundaries = request.partialBoundaries;
-
- for (i = 0; i < partialBoundaries.length; i++) {
- var _boundary2 = partialBoundaries[i];
-
- if (!flushPartialBoundary(request, destination, _boundary2)) {
- request.destination = null;
- i++;
- partialBoundaries.splice(0, i);
- return;
- }
- }
-
- partialBoundaries.splice(0, i); // Next we check the completed boundaries again. This may have had
- // boundaries added to it in case they were too larged to be inlined.
- // New ones might be added in this loop.
-
- var largeBoundaries = request.completedBoundaries;
-
- for (i = 0; i < largeBoundaries.length; i++) {
- var _boundary3 = largeBoundaries[i];
-
- if (!flushCompletedBoundary(request, destination, _boundary3)) {
- request.destination = null;
- i++;
- largeBoundaries.splice(0, i);
- return;
- }
- }
-
- largeBoundaries.splice(0, i);
- } finally {
- if (request.allPendingTasks === 0 && request.pingedTasks.length === 0 && request.clientRenderedBoundaries.length === 0 && request.completedBoundaries.length === 0 // We don't need to check any partially completed segments because
- // either they have pending task or they're complete.
- ) {
- {
- var postamble = request.postamble;
-
- for (var _i = 0; _i < postamble.length; _i++) {
- writeChunk(destination, postamble[_i]);
- }
- }
-
- {
- if (request.abortableTasks.size !== 0) {
- error('There was still abortable task at the root when we closed. This is a bug in React.');
- }
- } // We're done.
-
-
- close(destination);
- }
- }
-}
-
-function startWork(request) {
- scheduleWork(function () {
- return performWork(request);
- });
-}
-function startFlowing(request, destination) {
- if (request.status === CLOSING) {
- request.status = CLOSED;
- closeWithError(destination, request.fatalError);
- return;
- }
-
- if (request.status === CLOSED) {
- return;
- }
-
- if (request.destination !== null) {
- // We're already flowing.
- return;
- }
-
- request.destination = destination;
-
- try {
- flushCompletedQueues(request, destination);
- } catch (error) {
- logRecoverableError(request, error);
- fatalError(request, error);
- }
-} // This is called to early terminate a request. It puts all pending boundaries in client rendered state.
-
-function abort(request, reason) {
- try {
- var abortableTasks = request.abortableTasks;
-
- if (abortableTasks.size > 0) {
- var _error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
-
- abortableTasks.forEach(function (task) {
- return abortTask(task, request, _error);
- });
- abortableTasks.clear();
- }
-
- if (request.destination !== null) {
- flushCompletedQueues(request, request.destination);
- }
- } catch (error) {
- logRecoverableError(request, error);
- fatalError(request, error);
- }
-}
-
-function renderToReadableStream(children, options) {
- return new Promise(function (resolve, reject) {
- var onFatalError;
- var onAllReady;
- var allReady = new Promise(function (res, rej) {
- onAllReady = res;
- onFatalError = rej;
- });
-
- function onShellReady() {
- var stream = new ReadableStream({
- type: 'direct',
- pull: function (controller) {
- // $FlowIgnore
- startFlowing(request, controller);
- },
- cancel: function (reason) {
- abort(request);
- }
- }, // $FlowFixMe size() methods are not allowed on byte streams.
- {
- highWaterMark: 2048
- }); // TODO: Move to sub-classing ReadableStream.
-
- stream.allReady = allReady;
- resolve(stream);
- }
-
- function onShellError(error) {
- // If the shell errors the caller of `renderToReadableStream` won't have access to `allReady`.
- // However, `allReady` will be rejected by `onFatalError` as well.
- // So we need to catch the duplicate, uncatchable fatal error in `allReady` to prevent a `UnhandledPromiseRejection`.
- allReady.catch(function () {});
- reject(error);
- }
-
- var request = createRequest(children, createResponseState(options ? options.identifierPrefix : undefined, options ? options.nonce : undefined, options ? options.bootstrapScriptContent : undefined, options ? options.bootstrapScripts : undefined, options ? options.bootstrapModules : undefined, options ? options.unstable_externalRuntimeSrc : undefined), createRootFormatContext(options ? options.namespaceURI : undefined), options ? options.progressiveChunkSize : undefined, options ? options.onError : undefined, onAllReady, onShellReady, onShellError, onFatalError);
-
- if (options && options.signal) {
- var signal = options.signal;
-
- if (signal.aborted) {
- abort(request, signal.reason);
- } else {
- var listener = function () {
- abort(request, signal.reason);
- signal.removeEventListener('abort', listener);
- };
-
- signal.addEventListener('abort', listener);
- }
- }
-
- startWork(request);
- });
-}
-
-function renderToNodeStream() {
- throw new Error('ReactDOMServer.renderToNodeStream(): The Node Stream API is not available ' + 'in Bun. Use ReactDOMServer.renderToReadableStream() instead.');
-}
-
-function renderToStaticNodeStream() {
- throw new Error('ReactDOMServer.renderToStaticNodeStream(): The Node Stream API is not available ' + 'in Bun. Use ReactDOMServer.renderToReadableStream() instead.');
-}
-
-exports.renderToNodeStream = renderToNodeStream;
-exports.renderToReadableStream = renderToReadableStream;
-exports.renderToStaticNodeStream = renderToStaticNodeStream;
-exports.version = ReactVersion;
diff --git a/packages/next/compiled/react-dom/cjs/react-dom-server.bun.production.min.js b/packages/next/compiled/react-dom/cjs/react-dom-server.bun.production.min.js
deleted file mode 100644
index dda010059693222..000000000000000
--- a/packages/next/compiled/react-dom/cjs/react-dom-server.bun.production.min.js
+++ /dev/null
@@ -1,137 +0,0 @@
-/**
-* @license React
- * react-dom-server.bun.production.min.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';var ba=require("react"),ca=require("react-dom");function k(a,b){0!==b.length&&a.write(b)}function da(a,b){"function"===typeof a.error?a.error(b):a.close()}
-var r=Object.prototype.hasOwnProperty,ea=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,fa={},ha={};
-function ia(a){if(r.call(ha,a))return!0;if(r.call(fa,a))return!1;if(ea.test(a))return ha[a]=!0;fa[a]=!0;return!1}function t(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var v={};
-"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a){v[a]=new t(a,0,!1,a,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];v[b]=new t(b,1,!1,a[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(a){v[a]=new t(a,2,!1,a.toLowerCase(),null,!1,!1)});
-["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){v[a]=new t(a,2,!1,a,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){v[a]=new t(a,3,!1,a.toLowerCase(),null,!1,!1)});
-["checked","multiple","muted","selected"].forEach(function(a){v[a]=new t(a,3,!0,a,null,!1,!1)});["capture","download"].forEach(function(a){v[a]=new t(a,4,!1,a,null,!1,!1)});["cols","rows","size","span"].forEach(function(a){v[a]=new t(a,6,!1,a,null,!1,!1)});["rowSpan","start"].forEach(function(a){v[a]=new t(a,5,!1,a.toLowerCase(),null,!1,!1)});var ja=/[\-:]([a-z])/g;function ka(a){return a[1].toUpperCase()}
-"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(ja,
-ka);v[b]=new t(b,1,!1,a,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(ja,ka);v[b]=new t(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(ja,ka);v[b]=new t(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(a){v[a]=new t(a,1,!1,a.toLowerCase(),null,!1,!1)});
-v.xlinkHref=new t("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){v[a]=new t(a,1,!1,a.toLowerCase(),null,!0,!0)});
-var la={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,
-zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},ma=["Webkit","ms","Moz","O"];Object.keys(la).forEach(function(a){ma.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);la[b]=la[a]})});var na=/["'&<>]/;
-function w(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=na.exec(a);if(b){var c="",d,e=0;for(d=b.index;d":'');
var startScriptSrc = stringToPrecomputedChunk('');
+var completeSegmentScriptEnd = stringToPrecomputedChunk('")');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryScript3a = stringToPrecomputedChunk('",');
+var completeBoundaryScript3b = stringToPrecomputedChunk('"');
+var completeBoundaryScriptEnd = stringToPrecomputedChunk(')');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+var clientRenderScriptEnd = stringToPrecomputedChunk(')');
+var clientRenderData1 = stringToPrecomputedChunk('
+ return writeChunkAndReturn(destination, clientRenderScriptEnd);
+ }
}
var regexForJSStringsInInstructionScripts = /[<\u2028\u2029]/g;
@@ -4864,7 +4934,8 @@ function escapeJSObjectForInstructionScripts(input) {
var precedencePlaceholderStart = stringToPrecomputedChunk('');
-function writeInitialResources(destination, resources, responseState) {
+function writeInitialResources(destination, resources, responseState, willFlushAllSegments) {
+
function flushLinkResource(resource) {
if (!resource.flushed) {
pushLinkImpl(target, resource.props, responseState);
@@ -5088,20 +5159,22 @@ function hasStyleResourceDependencies(boundaryResources) {
var arrayFirstOpenBracket = stringToPrecomputedChunk('[');
var arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
var arrayInterstitial = stringToPrecomputedChunk(',');
-var arrayCloseBracket = stringToPrecomputedChunk(']');
+var arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
+// E.g.
+// [["JS_escaped_string1", "JS_escaped_string2"]]
-function writeStyleResourceDependencies(destination, boundaryResources) {
+function writeStyleResourceDependenciesInJS(destination, boundaryResources) {
writeChunk(destination, arrayFirstOpenBracket);
var nextArrayOpenBrackChunk = arrayFirstOpenBracket;
boundaryResources.forEach(function (resource) {
if (resource.inShell) ; else if (resource.flushed) {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependencyHrefOnly(destination, resource.href);
+ writeStyleResourceDependencyHrefOnlyInJS(destination, resource.href);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
} else {
writeChunk(destination, nextArrayOpenBrackChunk);
- writeStyleResourceDependency(destination, resource.href, resource.precedence, resource.props);
+ writeStyleResourceDependencyInJS(destination, resource.href, resource.precedence, resource.props);
writeChunk(destination, arrayCloseBracket);
nextArrayOpenBrackChunk = arraySubsequentOpenBracket;
resource.flushed = true;
@@ -5110,8 +5183,10 @@ function writeStyleResourceDependencies(destination, boundaryResources) {
});
writeChunk(destination, arrayCloseBracket);
}
+/* Helper functions */
-function writeStyleResourceDependencyHrefOnly(destination, href) {
+
+function writeStyleResourceDependencyHrefOnlyInJS(destination, href) {
// We should actually enforce this earlier when the resource is created but for
// now we make sure we are actually dealing with a string here.
{
@@ -5122,7 +5197,7 @@ function writeStyleResourceDependencyHrefOnly(destination, href) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(coercedHref)));
}
-function writeStyleResourceDependency(destination, href, precedence, props) {
+function writeStyleResourceDependencyInJS(destination, href, precedence, props) {
{
checkAttributeStringCoercion(href, 'href');
}
@@ -5162,7 +5237,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
// eslint-disable-next-line-no-fallthrough
default:
- writeStyleResourceAttribute(destination, propKey, propValue);
+ writeStyleResourceAttributeInJS(destination, propKey, propValue);
break;
}
}
@@ -5171,7 +5246,7 @@ function writeStyleResourceDependency(destination, href, precedence, props) {
return null;
}
-function writeStyleResourceAttribute(destination, name, value) {
+function writeStyleResourceAttributeInJS(destination, name, value) {
var attributeName = name.toLowerCase();
var attributeValue;
@@ -5241,7 +5316,7 @@ function writeStyleResourceAttribute(destination, name, value) {
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeName)));
writeChunk(destination, arrayInterstitial);
writeChunk(destination, stringToChunk(escapeJSObjectForInstructionScripts(attributeValue)));
-}
+} // This function writes a 2D array of strings to be embedded in an attribute
// ATTENTION
// When adding new symbols to this file,
@@ -8886,7 +8961,7 @@ function flushSegment(request, destination, segment) {
}
}
-function flushInitialResources(destination, resources, responseState) {
+function flushInitialResources(destination, resources, responseState, willFlushAllSegments) {
writeInitialResources(destination, resources, responseState);
}
@@ -8990,7 +9065,7 @@ function flushCompletedQueues(request, destination) {
writeChunk(destination, preamble[i]);
}
- flushInitialResources(destination, request.resources, request.responseState);
+ flushInitialResources(destination, request.resources, request.responseState, request.allPendingTasks === 0);
}
flushSegment(request, destination, completedRootSegment);
diff --git a/packages/next/compiled/react-dom/cjs/react-dom-server.node.production.min.js b/packages/next/compiled/react-dom/cjs/react-dom-server.node.production.min.js
index 7ea9f6d528f519e..2c905d18673bd82 100644
--- a/packages/next/compiled/react-dom/cjs/react-dom-server.node.production.min.js
+++ b/packages/next/compiled/react-dom/cjs/react-dom-server.node.production.min.js
@@ -22,7 +22,7 @@ var ra={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderIma
zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},sa=["Webkit","ms","Moz","O"];Object.keys(ra).forEach(function(a){sa.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);ra[b]=ra[a]})});var ta=/["'&<>]/;
function C(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=ta.exec(a);if(b){var c="",d,e=0;for(d=b.index;d"),La=x("\x3c/script>"),Ma=x('');
var startScriptSrc = stringToPrecomputedChunk('');
+var completeSegmentData1 = stringToPrecomputedChunk('');
+var completeBoundaryScript3a = stringToPrecomputedChunk('",');
+var completeBoundaryScript3b = stringToPrecomputedChunk('"');
+var completeBoundaryScriptEnd = stringToPrecomputedChunk(')');
+var completeBoundaryData1 = stringToPrecomputedChunk('');
var clientRenderErrorScriptArgInterstitial = stringToPrecomputedChunk(',');
+var clientRenderScriptEnd = stringToPrecomputedChunk(')');
+var clientRenderData1 = stringToPrecomputedChunk('');
@@ -671,7 +682,7 @@ var precedencePlaceholderEnd = stringToPrecomputedChunk('">');
var arrayFirstOpenBracket = stringToPrecomputedChunk('[');
var arraySubsequentOpenBracket = stringToPrecomputedChunk(',[');
var arrayInterstitial = stringToPrecomputedChunk(',');
-var arrayCloseBracket = stringToPrecomputedChunk(']');
+var arrayCloseBracket = stringToPrecomputedChunk(']'); // This function writes a 2D array of strings to be embedded in javascript.
var rendererSigil;
@@ -2396,13 +2407,14 @@ function x(a,b,d,c,f,g,h){this.acceptsBooleans=2===b||3===b||4===b;this.attribut
A);new x(b,1,!1,a,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(z,A);new x(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(z,A);new x(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(a){new x(a,1,!1,a.toLowerCase(),null,!1,!1)});
new x("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){new x(a,1,!1,a.toLowerCase(),null,!0,!0)});
var B={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,
-fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},ra=["Webkit","ms","Moz","O"];Object.keys(B).forEach(function(a){ra.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);B[b]=B[a]})});var sa=Array.isArray;r("