5166 lines
184 KiB
JavaScript
5166 lines
184 KiB
JavaScript
/**
|
|
* @license React
|
|
* react-server-dom-webpack-client.browser.development.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
"use strict";
|
|
"production" !== process.env.NODE_ENV &&
|
|
(function () {
|
|
function resolveClientReference(bundlerConfig, metadata) {
|
|
if (bundlerConfig) {
|
|
var moduleExports = bundlerConfig[metadata[0]];
|
|
if ((bundlerConfig = moduleExports && moduleExports[metadata[2]]))
|
|
moduleExports = bundlerConfig.name;
|
|
else {
|
|
bundlerConfig = moduleExports && moduleExports["*"];
|
|
if (!bundlerConfig)
|
|
throw Error(
|
|
'Could not find the module "' +
|
|
metadata[0] +
|
|
'" in the React Server Consumer Manifest. This is probably a bug in the React Server Components bundler.'
|
|
);
|
|
moduleExports = metadata[2];
|
|
}
|
|
return 4 === metadata.length
|
|
? [bundlerConfig.id, bundlerConfig.chunks, moduleExports, 1]
|
|
: [bundlerConfig.id, bundlerConfig.chunks, moduleExports];
|
|
}
|
|
return metadata;
|
|
}
|
|
function resolveServerReference(bundlerConfig, id) {
|
|
var name = "",
|
|
resolvedModuleData = bundlerConfig[id];
|
|
if (resolvedModuleData) name = resolvedModuleData.name;
|
|
else {
|
|
var idx = id.lastIndexOf("#");
|
|
-1 !== idx &&
|
|
((name = id.slice(idx + 1)),
|
|
(resolvedModuleData = bundlerConfig[id.slice(0, idx)]));
|
|
if (!resolvedModuleData)
|
|
throw Error(
|
|
'Could not find the module "' +
|
|
id +
|
|
'" in the React Server Manifest. This is probably a bug in the React Server Components bundler.'
|
|
);
|
|
}
|
|
return resolvedModuleData.async
|
|
? [resolvedModuleData.id, resolvedModuleData.chunks, name, 1]
|
|
: [resolvedModuleData.id, resolvedModuleData.chunks, name];
|
|
}
|
|
function requireAsyncModule(id) {
|
|
var promise = __webpack_require__(id);
|
|
if ("function" !== typeof promise.then || "fulfilled" === promise.status)
|
|
return null;
|
|
promise.then(
|
|
function (value) {
|
|
promise.status = "fulfilled";
|
|
promise.value = value;
|
|
},
|
|
function (reason) {
|
|
promise.status = "rejected";
|
|
promise.reason = reason;
|
|
}
|
|
);
|
|
return promise;
|
|
}
|
|
function ignoreReject() {}
|
|
function preloadModule(metadata) {
|
|
for (
|
|
var chunks = metadata[1], promises = [], i = 0;
|
|
i < chunks.length;
|
|
|
|
) {
|
|
var chunkId = chunks[i++],
|
|
chunkFilename = chunks[i++],
|
|
entry = chunkCache.get(chunkId);
|
|
void 0 === entry
|
|
? ((chunkFilename = loadChunk(chunkId, chunkFilename)),
|
|
promises.push(chunkFilename),
|
|
(entry = chunkCache.set.bind(chunkCache, chunkId, null)),
|
|
chunkFilename.then(entry, ignoreReject),
|
|
chunkCache.set(chunkId, chunkFilename))
|
|
: null !== entry && promises.push(entry);
|
|
}
|
|
return 4 === metadata.length
|
|
? 0 === promises.length
|
|
? requireAsyncModule(metadata[0])
|
|
: Promise.all(promises).then(function () {
|
|
return requireAsyncModule(metadata[0]);
|
|
})
|
|
: 0 < promises.length
|
|
? Promise.all(promises)
|
|
: null;
|
|
}
|
|
function requireModule(metadata) {
|
|
var moduleExports = __webpack_require__(metadata[0]);
|
|
if (4 === metadata.length && "function" === typeof moduleExports.then)
|
|
if ("fulfilled" === moduleExports.status)
|
|
moduleExports = moduleExports.value;
|
|
else throw moduleExports.reason;
|
|
if ("*" === metadata[2]) return moduleExports;
|
|
if ("" === metadata[2])
|
|
return moduleExports.__esModule ? moduleExports.default : moduleExports;
|
|
if (hasOwnProperty.call(moduleExports, metadata[2]))
|
|
return moduleExports[metadata[2]];
|
|
}
|
|
function loadChunk(chunkId, filename) {
|
|
chunkMap.set(chunkId, filename);
|
|
return __webpack_chunk_load__(chunkId);
|
|
}
|
|
function getIteratorFn(maybeIterable) {
|
|
if (null === maybeIterable || "object" !== typeof maybeIterable)
|
|
return null;
|
|
maybeIterable =
|
|
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
|
|
maybeIterable["@@iterator"];
|
|
return "function" === typeof maybeIterable ? maybeIterable : null;
|
|
}
|
|
function isObjectPrototype(object) {
|
|
if (!object) return !1;
|
|
var ObjectPrototype = Object.prototype;
|
|
if (object === ObjectPrototype) return !0;
|
|
if (getPrototypeOf(object)) return !1;
|
|
object = Object.getOwnPropertyNames(object);
|
|
for (var i = 0; i < object.length; i++)
|
|
if (!(object[i] in ObjectPrototype)) return !1;
|
|
return !0;
|
|
}
|
|
function isSimpleObject(object) {
|
|
if (!isObjectPrototype(getPrototypeOf(object))) return !1;
|
|
for (
|
|
var names = Object.getOwnPropertyNames(object), i = 0;
|
|
i < names.length;
|
|
i++
|
|
) {
|
|
var descriptor = Object.getOwnPropertyDescriptor(object, names[i]);
|
|
if (
|
|
!descriptor ||
|
|
(!descriptor.enumerable &&
|
|
(("key" !== names[i] && "ref" !== names[i]) ||
|
|
"function" !== typeof descriptor.get))
|
|
)
|
|
return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
function objectName(object) {
|
|
object = Object.prototype.toString.call(object);
|
|
return object.slice(8, object.length - 1);
|
|
}
|
|
function describeKeyForErrorMessage(key) {
|
|
var encodedKey = JSON.stringify(key);
|
|
return '"' + key + '"' === encodedKey ? key : encodedKey;
|
|
}
|
|
function describeValueForErrorMessage(value) {
|
|
switch (typeof value) {
|
|
case "string":
|
|
return JSON.stringify(
|
|
10 >= value.length ? value : value.slice(0, 10) + "..."
|
|
);
|
|
case "object":
|
|
if (isArrayImpl(value)) return "[...]";
|
|
if (null !== value && value.$$typeof === CLIENT_REFERENCE_TAG)
|
|
return "client";
|
|
value = objectName(value);
|
|
return "Object" === value ? "{...}" : value;
|
|
case "function":
|
|
return value.$$typeof === CLIENT_REFERENCE_TAG
|
|
? "client"
|
|
: (value = value.displayName || value.name)
|
|
? "function " + value
|
|
: "function";
|
|
default:
|
|
return String(value);
|
|
}
|
|
}
|
|
function describeElementType(type) {
|
|
if ("string" === typeof type) return type;
|
|
switch (type) {
|
|
case REACT_SUSPENSE_TYPE:
|
|
return "Suspense";
|
|
case REACT_SUSPENSE_LIST_TYPE:
|
|
return "SuspenseList";
|
|
case REACT_VIEW_TRANSITION_TYPE:
|
|
return "ViewTransition";
|
|
}
|
|
if ("object" === typeof type)
|
|
switch (type.$$typeof) {
|
|
case REACT_FORWARD_REF_TYPE:
|
|
return describeElementType(type.render);
|
|
case REACT_MEMO_TYPE:
|
|
return describeElementType(type.type);
|
|
case REACT_LAZY_TYPE:
|
|
var payload = type._payload;
|
|
type = type._init;
|
|
try {
|
|
return describeElementType(type(payload));
|
|
} catch (x) {}
|
|
}
|
|
return "";
|
|
}
|
|
function describeObjectForErrorMessage(objectOrArray, expandedName) {
|
|
var objKind = objectName(objectOrArray);
|
|
if ("Object" !== objKind && "Array" !== objKind) return objKind;
|
|
var start = -1,
|
|
length = 0;
|
|
if (isArrayImpl(objectOrArray))
|
|
if (jsxChildrenParents.has(objectOrArray)) {
|
|
var type = jsxChildrenParents.get(objectOrArray);
|
|
objKind = "<" + describeElementType(type) + ">";
|
|
for (var i = 0; i < objectOrArray.length; i++) {
|
|
var value = objectOrArray[i];
|
|
value =
|
|
"string" === typeof value
|
|
? value
|
|
: "object" === typeof value && null !== value
|
|
? "{" + describeObjectForErrorMessage(value) + "}"
|
|
: "{" + describeValueForErrorMessage(value) + "}";
|
|
"" + i === expandedName
|
|
? ((start = objKind.length),
|
|
(length = value.length),
|
|
(objKind += value))
|
|
: (objKind =
|
|
15 > value.length && 40 > objKind.length + value.length
|
|
? objKind + value
|
|
: objKind + "{...}");
|
|
}
|
|
objKind += "</" + describeElementType(type) + ">";
|
|
} else {
|
|
objKind = "[";
|
|
for (type = 0; type < objectOrArray.length; type++)
|
|
0 < type && (objKind += ", "),
|
|
(i = objectOrArray[type]),
|
|
(i =
|
|
"object" === typeof i && null !== i
|
|
? describeObjectForErrorMessage(i)
|
|
: describeValueForErrorMessage(i)),
|
|
"" + type === expandedName
|
|
? ((start = objKind.length),
|
|
(length = i.length),
|
|
(objKind += i))
|
|
: (objKind =
|
|
10 > i.length && 40 > objKind.length + i.length
|
|
? objKind + i
|
|
: objKind + "...");
|
|
objKind += "]";
|
|
}
|
|
else if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE)
|
|
objKind = "<" + describeElementType(objectOrArray.type) + "/>";
|
|
else {
|
|
if (objectOrArray.$$typeof === CLIENT_REFERENCE_TAG) return "client";
|
|
if (jsxPropsParents.has(objectOrArray)) {
|
|
objKind = jsxPropsParents.get(objectOrArray);
|
|
objKind = "<" + (describeElementType(objKind) || "...");
|
|
type = Object.keys(objectOrArray);
|
|
for (i = 0; i < type.length; i++) {
|
|
objKind += " ";
|
|
value = type[i];
|
|
objKind += describeKeyForErrorMessage(value) + "=";
|
|
var _value2 = objectOrArray[value];
|
|
var _substr2 =
|
|
value === expandedName &&
|
|
"object" === typeof _value2 &&
|
|
null !== _value2
|
|
? describeObjectForErrorMessage(_value2)
|
|
: describeValueForErrorMessage(_value2);
|
|
"string" !== typeof _value2 && (_substr2 = "{" + _substr2 + "}");
|
|
value === expandedName
|
|
? ((start = objKind.length),
|
|
(length = _substr2.length),
|
|
(objKind += _substr2))
|
|
: (objKind =
|
|
10 > _substr2.length && 40 > objKind.length + _substr2.length
|
|
? objKind + _substr2
|
|
: objKind + "...");
|
|
}
|
|
objKind += ">";
|
|
} else {
|
|
objKind = "{";
|
|
type = Object.keys(objectOrArray);
|
|
for (i = 0; i < type.length; i++)
|
|
0 < i && (objKind += ", "),
|
|
(value = type[i]),
|
|
(objKind += describeKeyForErrorMessage(value) + ": "),
|
|
(_value2 = objectOrArray[value]),
|
|
(_value2 =
|
|
"object" === typeof _value2 && null !== _value2
|
|
? describeObjectForErrorMessage(_value2)
|
|
: describeValueForErrorMessage(_value2)),
|
|
value === expandedName
|
|
? ((start = objKind.length),
|
|
(length = _value2.length),
|
|
(objKind += _value2))
|
|
: (objKind =
|
|
10 > _value2.length && 40 > objKind.length + _value2.length
|
|
? objKind + _value2
|
|
: objKind + "...");
|
|
objKind += "}";
|
|
}
|
|
}
|
|
return void 0 === expandedName
|
|
? objKind
|
|
: -1 < start && 0 < length
|
|
? ((objectOrArray = " ".repeat(start) + "^".repeat(length)),
|
|
"\n " + objKind + "\n " + objectOrArray)
|
|
: "\n " + objKind;
|
|
}
|
|
function serializeNumber(number) {
|
|
return Number.isFinite(number)
|
|
? 0 === number && -Infinity === 1 / number
|
|
? "$-0"
|
|
: number
|
|
: Infinity === number
|
|
? "$Infinity"
|
|
: -Infinity === number
|
|
? "$-Infinity"
|
|
: "$NaN";
|
|
}
|
|
function processReply(
|
|
root,
|
|
formFieldPrefix,
|
|
temporaryReferences,
|
|
resolve,
|
|
reject
|
|
) {
|
|
function serializeTypedArray(tag, typedArray) {
|
|
typedArray = new Blob([
|
|
new Uint8Array(
|
|
typedArray.buffer,
|
|
typedArray.byteOffset,
|
|
typedArray.byteLength
|
|
)
|
|
]);
|
|
var blobId = nextPartId++;
|
|
null === formData && (formData = new FormData());
|
|
formData.append(formFieldPrefix + blobId, typedArray);
|
|
return "$" + tag + blobId.toString(16);
|
|
}
|
|
function serializeBinaryReader(reader) {
|
|
function progress(entry) {
|
|
entry.done
|
|
? ((entry = nextPartId++),
|
|
data.append(formFieldPrefix + entry, new Blob(buffer)),
|
|
data.append(
|
|
formFieldPrefix + streamId,
|
|
'"$o' + entry.toString(16) + '"'
|
|
),
|
|
data.append(formFieldPrefix + streamId, "C"),
|
|
pendingParts--,
|
|
0 === pendingParts && resolve(data))
|
|
: (buffer.push(entry.value),
|
|
reader.read(new Uint8Array(1024)).then(progress, reject));
|
|
}
|
|
null === formData && (formData = new FormData());
|
|
var data = formData;
|
|
pendingParts++;
|
|
var streamId = nextPartId++,
|
|
buffer = [];
|
|
reader.read(new Uint8Array(1024)).then(progress, reject);
|
|
return "$r" + streamId.toString(16);
|
|
}
|
|
function serializeReader(reader) {
|
|
function progress(entry) {
|
|
if (entry.done)
|
|
data.append(formFieldPrefix + streamId, "C"),
|
|
pendingParts--,
|
|
0 === pendingParts && resolve(data);
|
|
else
|
|
try {
|
|
var partJSON = JSON.stringify(entry.value, resolveToJSON);
|
|
data.append(formFieldPrefix + streamId, partJSON);
|
|
reader.read().then(progress, reject);
|
|
} catch (x) {
|
|
reject(x);
|
|
}
|
|
}
|
|
null === formData && (formData = new FormData());
|
|
var data = formData;
|
|
pendingParts++;
|
|
var streamId = nextPartId++;
|
|
reader.read().then(progress, reject);
|
|
return "$R" + streamId.toString(16);
|
|
}
|
|
function serializeReadableStream(stream) {
|
|
try {
|
|
var binaryReader = stream.getReader({ mode: "byob" });
|
|
} catch (x) {
|
|
return serializeReader(stream.getReader());
|
|
}
|
|
return serializeBinaryReader(binaryReader);
|
|
}
|
|
function serializeAsyncIterable(iterable, iterator) {
|
|
function progress(entry) {
|
|
if (entry.done) {
|
|
if (void 0 === entry.value)
|
|
data.append(formFieldPrefix + streamId, "C");
|
|
else
|
|
try {
|
|
var partJSON = JSON.stringify(entry.value, resolveToJSON);
|
|
data.append(formFieldPrefix + streamId, "C" + partJSON);
|
|
} catch (x) {
|
|
reject(x);
|
|
return;
|
|
}
|
|
pendingParts--;
|
|
0 === pendingParts && resolve(data);
|
|
} else
|
|
try {
|
|
var _partJSON = JSON.stringify(entry.value, resolveToJSON);
|
|
data.append(formFieldPrefix + streamId, _partJSON);
|
|
iterator.next().then(progress, reject);
|
|
} catch (x$0) {
|
|
reject(x$0);
|
|
}
|
|
}
|
|
null === formData && (formData = new FormData());
|
|
var data = formData;
|
|
pendingParts++;
|
|
var streamId = nextPartId++;
|
|
iterable = iterable === iterator;
|
|
iterator.next().then(progress, reject);
|
|
return "$" + (iterable ? "x" : "X") + streamId.toString(16);
|
|
}
|
|
function resolveToJSON(key, value) {
|
|
"__proto__" === key &&
|
|
console.error(
|
|
"Expected not to serialize an object with own property `__proto__`. When parsed this property will be omitted.%s",
|
|
describeObjectForErrorMessage(this, key)
|
|
);
|
|
var originalValue = this[key];
|
|
"object" !== typeof originalValue ||
|
|
originalValue === value ||
|
|
originalValue instanceof Date ||
|
|
("Object" !== objectName(originalValue)
|
|
? console.error(
|
|
"Only plain objects can be passed to Server Functions from the Client. %s objects are not supported.%s",
|
|
objectName(originalValue),
|
|
describeObjectForErrorMessage(this, key)
|
|
)
|
|
: console.error(
|
|
"Only plain objects can be passed to Server Functions from the Client. Objects with toJSON methods are not supported. Convert it manually to a simple value before passing it to props.%s",
|
|
describeObjectForErrorMessage(this, key)
|
|
));
|
|
if (null === value) return null;
|
|
if ("object" === typeof value) {
|
|
switch (value.$$typeof) {
|
|
case REACT_ELEMENT_TYPE:
|
|
if (void 0 !== temporaryReferences && -1 === key.indexOf(":")) {
|
|
var parentReference = writtenObjects.get(this);
|
|
if (void 0 !== parentReference)
|
|
return (
|
|
temporaryReferences.set(parentReference + ":" + key, value),
|
|
"$T"
|
|
);
|
|
}
|
|
throw Error(
|
|
"React Element cannot be passed to Server Functions from the Client without a temporary reference set. Pass a TemporaryReferenceSet to the options." +
|
|
describeObjectForErrorMessage(this, key)
|
|
);
|
|
case REACT_LAZY_TYPE:
|
|
originalValue = value._payload;
|
|
var init = value._init;
|
|
null === formData && (formData = new FormData());
|
|
pendingParts++;
|
|
try {
|
|
parentReference = init(originalValue);
|
|
var lazyId = nextPartId++,
|
|
partJSON = serializeModel(parentReference, lazyId);
|
|
formData.append(formFieldPrefix + lazyId, partJSON);
|
|
return "$" + lazyId.toString(16);
|
|
} catch (x) {
|
|
if (
|
|
"object" === typeof x &&
|
|
null !== x &&
|
|
"function" === typeof x.then
|
|
) {
|
|
pendingParts++;
|
|
var _lazyId = nextPartId++;
|
|
parentReference = function () {
|
|
try {
|
|
var _partJSON2 = serializeModel(value, _lazyId),
|
|
_data = formData;
|
|
_data.append(formFieldPrefix + _lazyId, _partJSON2);
|
|
pendingParts--;
|
|
0 === pendingParts && resolve(_data);
|
|
} catch (reason) {
|
|
reject(reason);
|
|
}
|
|
};
|
|
x.then(parentReference, parentReference);
|
|
return "$" + _lazyId.toString(16);
|
|
}
|
|
reject(x);
|
|
return null;
|
|
} finally {
|
|
pendingParts--;
|
|
}
|
|
}
|
|
parentReference = writtenObjects.get(value);
|
|
if ("function" === typeof value.then) {
|
|
if (void 0 !== parentReference)
|
|
if (modelRoot === value) modelRoot = null;
|
|
else return parentReference;
|
|
null === formData && (formData = new FormData());
|
|
pendingParts++;
|
|
var promiseId = nextPartId++;
|
|
key = "$@" + promiseId.toString(16);
|
|
writtenObjects.set(value, key);
|
|
value.then(function (partValue) {
|
|
try {
|
|
var previousReference = writtenObjects.get(partValue);
|
|
var _partJSON3 =
|
|
void 0 !== previousReference
|
|
? JSON.stringify(previousReference)
|
|
: serializeModel(partValue, promiseId);
|
|
partValue = formData;
|
|
partValue.append(formFieldPrefix + promiseId, _partJSON3);
|
|
pendingParts--;
|
|
0 === pendingParts && resolve(partValue);
|
|
} catch (reason) {
|
|
reject(reason);
|
|
}
|
|
}, reject);
|
|
return key;
|
|
}
|
|
if (void 0 !== parentReference)
|
|
if (modelRoot === value) modelRoot = null;
|
|
else return parentReference;
|
|
else
|
|
-1 === key.indexOf(":") &&
|
|
((parentReference = writtenObjects.get(this)),
|
|
void 0 !== parentReference &&
|
|
((parentReference = parentReference + ":" + key),
|
|
writtenObjects.set(value, parentReference),
|
|
void 0 !== temporaryReferences &&
|
|
temporaryReferences.set(parentReference, value)));
|
|
if (isArrayImpl(value)) return value;
|
|
if (value instanceof FormData) {
|
|
null === formData && (formData = new FormData());
|
|
var _data3 = formData;
|
|
key = nextPartId++;
|
|
var prefix = formFieldPrefix + key + "_";
|
|
value.forEach(function (originalValue, originalKey) {
|
|
_data3.append(prefix + originalKey, originalValue);
|
|
});
|
|
return "$K" + key.toString(16);
|
|
}
|
|
if (value instanceof Map)
|
|
return (
|
|
(key = nextPartId++),
|
|
(parentReference = serializeModel(Array.from(value), key)),
|
|
null === formData && (formData = new FormData()),
|
|
formData.append(formFieldPrefix + key, parentReference),
|
|
"$Q" + key.toString(16)
|
|
);
|
|
if (value instanceof Set)
|
|
return (
|
|
(key = nextPartId++),
|
|
(parentReference = serializeModel(Array.from(value), key)),
|
|
null === formData && (formData = new FormData()),
|
|
formData.append(formFieldPrefix + key, parentReference),
|
|
"$W" + key.toString(16)
|
|
);
|
|
if (value instanceof ArrayBuffer)
|
|
return (
|
|
(key = new Blob([value])),
|
|
(parentReference = nextPartId++),
|
|
null === formData && (formData = new FormData()),
|
|
formData.append(formFieldPrefix + parentReference, key),
|
|
"$A" + parentReference.toString(16)
|
|
);
|
|
if (value instanceof Int8Array)
|
|
return serializeTypedArray("O", value);
|
|
if (value instanceof Uint8Array)
|
|
return serializeTypedArray("o", value);
|
|
if (value instanceof Uint8ClampedArray)
|
|
return serializeTypedArray("U", value);
|
|
if (value instanceof Int16Array)
|
|
return serializeTypedArray("S", value);
|
|
if (value instanceof Uint16Array)
|
|
return serializeTypedArray("s", value);
|
|
if (value instanceof Int32Array)
|
|
return serializeTypedArray("L", value);
|
|
if (value instanceof Uint32Array)
|
|
return serializeTypedArray("l", value);
|
|
if (value instanceof Float32Array)
|
|
return serializeTypedArray("G", value);
|
|
if (value instanceof Float64Array)
|
|
return serializeTypedArray("g", value);
|
|
if (value instanceof BigInt64Array)
|
|
return serializeTypedArray("M", value);
|
|
if (value instanceof BigUint64Array)
|
|
return serializeTypedArray("m", value);
|
|
if (value instanceof DataView) return serializeTypedArray("V", value);
|
|
if ("function" === typeof Blob && value instanceof Blob)
|
|
return (
|
|
null === formData && (formData = new FormData()),
|
|
(key = nextPartId++),
|
|
formData.append(formFieldPrefix + key, value),
|
|
"$B" + key.toString(16)
|
|
);
|
|
if ((parentReference = getIteratorFn(value)))
|
|
return (
|
|
(parentReference = parentReference.call(value)),
|
|
parentReference === value
|
|
? ((key = nextPartId++),
|
|
(parentReference = serializeModel(
|
|
Array.from(parentReference),
|
|
key
|
|
)),
|
|
null === formData && (formData = new FormData()),
|
|
formData.append(formFieldPrefix + key, parentReference),
|
|
"$i" + key.toString(16))
|
|
: Array.from(parentReference)
|
|
);
|
|
if (
|
|
"function" === typeof ReadableStream &&
|
|
value instanceof ReadableStream
|
|
)
|
|
return serializeReadableStream(value);
|
|
parentReference = value[ASYNC_ITERATOR];
|
|
if ("function" === typeof parentReference)
|
|
return serializeAsyncIterable(value, parentReference.call(value));
|
|
parentReference = getPrototypeOf(value);
|
|
if (
|
|
parentReference !== ObjectPrototype &&
|
|
(null === parentReference ||
|
|
null !== getPrototypeOf(parentReference))
|
|
) {
|
|
if (void 0 === temporaryReferences)
|
|
throw Error(
|
|
"Only plain objects, and a few built-ins, can be passed to Server Functions. Classes or null prototypes are not supported." +
|
|
describeObjectForErrorMessage(this, key)
|
|
);
|
|
return "$T";
|
|
}
|
|
value.$$typeof === REACT_CONTEXT_TYPE
|
|
? console.error(
|
|
"React Context Providers cannot be passed to Server Functions from the Client.%s",
|
|
describeObjectForErrorMessage(this, key)
|
|
)
|
|
: "Object" !== objectName(value)
|
|
? console.error(
|
|
"Only plain objects can be passed to Server Functions from the Client. %s objects are not supported.%s",
|
|
objectName(value),
|
|
describeObjectForErrorMessage(this, key)
|
|
)
|
|
: isSimpleObject(value)
|
|
? Object.getOwnPropertySymbols &&
|
|
((parentReference = Object.getOwnPropertySymbols(value)),
|
|
0 < parentReference.length &&
|
|
console.error(
|
|
"Only plain objects can be passed to Server Functions from the Client. Objects with symbol properties like %s are not supported.%s",
|
|
parentReference[0].description,
|
|
describeObjectForErrorMessage(this, key)
|
|
))
|
|
: console.error(
|
|
"Only plain objects can be passed to Server Functions from the Client. Classes or other objects with methods are not supported.%s",
|
|
describeObjectForErrorMessage(this, key)
|
|
);
|
|
return value;
|
|
}
|
|
if ("string" === typeof value) {
|
|
if ("Z" === value[value.length - 1] && this[key] instanceof Date)
|
|
return "$D" + value;
|
|
key = "$" === value[0] ? "$" + value : value;
|
|
return key;
|
|
}
|
|
if ("boolean" === typeof value) return value;
|
|
if ("number" === typeof value) return serializeNumber(value);
|
|
if ("undefined" === typeof value) return "$undefined";
|
|
if ("function" === typeof value) {
|
|
parentReference = knownServerReferences.get(value);
|
|
if (void 0 !== parentReference) {
|
|
key = writtenObjects.get(value);
|
|
if (void 0 !== key) return key;
|
|
key = JSON.stringify(
|
|
{ id: parentReference.id, bound: parentReference.bound },
|
|
resolveToJSON
|
|
);
|
|
null === formData && (formData = new FormData());
|
|
parentReference = nextPartId++;
|
|
formData.set(formFieldPrefix + parentReference, key);
|
|
key = "$h" + parentReference.toString(16);
|
|
writtenObjects.set(value, key);
|
|
return key;
|
|
}
|
|
if (
|
|
void 0 !== temporaryReferences &&
|
|
-1 === key.indexOf(":") &&
|
|
((parentReference = writtenObjects.get(this)),
|
|
void 0 !== parentReference)
|
|
)
|
|
return (
|
|
temporaryReferences.set(parentReference + ":" + key, value), "$T"
|
|
);
|
|
throw Error(
|
|
"Client Functions cannot be passed directly to Server Functions. Only Functions passed from the Server can be passed back again."
|
|
);
|
|
}
|
|
if ("symbol" === typeof value) {
|
|
if (
|
|
void 0 !== temporaryReferences &&
|
|
-1 === key.indexOf(":") &&
|
|
((parentReference = writtenObjects.get(this)),
|
|
void 0 !== parentReference)
|
|
)
|
|
return (
|
|
temporaryReferences.set(parentReference + ":" + key, value), "$T"
|
|
);
|
|
throw Error(
|
|
"Symbols cannot be passed to a Server Function without a temporary reference set. Pass a TemporaryReferenceSet to the options." +
|
|
describeObjectForErrorMessage(this, key)
|
|
);
|
|
}
|
|
if ("bigint" === typeof value) return "$n" + value.toString(10);
|
|
throw Error(
|
|
"Type " +
|
|
typeof value +
|
|
" is not supported as an argument to a Server Function."
|
|
);
|
|
}
|
|
function serializeModel(model, id) {
|
|
"object" === typeof model &&
|
|
null !== model &&
|
|
((id = "$" + id.toString(16)),
|
|
writtenObjects.set(model, id),
|
|
void 0 !== temporaryReferences && temporaryReferences.set(id, model));
|
|
modelRoot = model;
|
|
return JSON.stringify(model, resolveToJSON);
|
|
}
|
|
var nextPartId = 1,
|
|
pendingParts = 0,
|
|
formData = null,
|
|
writtenObjects = new WeakMap(),
|
|
modelRoot = root,
|
|
json = serializeModel(root, 0);
|
|
null === formData
|
|
? resolve(json)
|
|
: (formData.set(formFieldPrefix + "0", json),
|
|
0 === pendingParts && resolve(formData));
|
|
return function () {
|
|
0 < pendingParts &&
|
|
((pendingParts = 0),
|
|
null === formData ? resolve(json) : resolve(formData));
|
|
};
|
|
}
|
|
function createFakeServerFunction(
|
|
name,
|
|
filename,
|
|
sourceMap,
|
|
line,
|
|
col,
|
|
environmentName,
|
|
innerFunction
|
|
) {
|
|
name || (name = "<anonymous>");
|
|
var encodedName = JSON.stringify(name);
|
|
1 >= line
|
|
? ((line = encodedName.length + 7),
|
|
(col =
|
|
"s=>({" +
|
|
encodedName +
|
|
" ".repeat(col < line ? 0 : col - line) +
|
|
":(...args) => s(...args)})\n/* This module is a proxy to a Server Action. Turn on Source Maps to see the server source. */"))
|
|
: (col =
|
|
"/* This module is a proxy to a Server Action. Turn on Source Maps to see the server source. */" +
|
|
"\n".repeat(line - 2) +
|
|
"server=>({" +
|
|
encodedName +
|
|
":\n" +
|
|
" ".repeat(1 > col ? 0 : col - 1) +
|
|
"(...args) => server(...args)})");
|
|
filename.startsWith("/") && (filename = "file://" + filename);
|
|
sourceMap
|
|
? ((col +=
|
|
"\n//# sourceURL=about://React/" +
|
|
encodeURIComponent(environmentName) +
|
|
"/" +
|
|
encodeURI(filename) +
|
|
"?s" +
|
|
fakeServerFunctionIdx++),
|
|
(col += "\n//# sourceMappingURL=" + sourceMap))
|
|
: filename && (col += "\n//# sourceURL=" + filename);
|
|
try {
|
|
return (0, eval)(col)(innerFunction)[name];
|
|
} catch (x) {
|
|
return innerFunction;
|
|
}
|
|
}
|
|
function registerBoundServerReference(reference, id, bound) {
|
|
knownServerReferences.has(reference) ||
|
|
knownServerReferences.set(reference, {
|
|
id: id,
|
|
originalBind: reference.bind,
|
|
bound: bound
|
|
});
|
|
}
|
|
function createBoundServerReference(
|
|
metaData,
|
|
callServer,
|
|
encodeFormAction,
|
|
findSourceMapURL
|
|
) {
|
|
function action() {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
return bound
|
|
? "fulfilled" === bound.status
|
|
? callServer(id, bound.value.concat(args))
|
|
: Promise.resolve(bound).then(function (boundArgs) {
|
|
return callServer(id, boundArgs.concat(args));
|
|
})
|
|
: callServer(id, args);
|
|
}
|
|
var id = metaData.id,
|
|
bound = metaData.bound,
|
|
location = metaData.location;
|
|
if (location) {
|
|
encodeFormAction = metaData.name || "";
|
|
var filename = location[1],
|
|
line = location[2];
|
|
location = location[3];
|
|
metaData = metaData.env || "Server";
|
|
findSourceMapURL =
|
|
null == findSourceMapURL
|
|
? null
|
|
: findSourceMapURL(filename, metaData);
|
|
action = createFakeServerFunction(
|
|
encodeFormAction,
|
|
filename,
|
|
findSourceMapURL,
|
|
line,
|
|
location,
|
|
metaData,
|
|
action
|
|
);
|
|
}
|
|
registerBoundServerReference(action, id, bound);
|
|
return action;
|
|
}
|
|
function parseStackLocation(error) {
|
|
error = error.stack;
|
|
error.startsWith("Error: react-stack-top-frame\n") &&
|
|
(error = error.slice(29));
|
|
var endOfFirst = error.indexOf("\n");
|
|
if (-1 !== endOfFirst) {
|
|
var endOfSecond = error.indexOf("\n", endOfFirst + 1);
|
|
endOfFirst =
|
|
-1 === endOfSecond
|
|
? error.slice(endOfFirst + 1)
|
|
: error.slice(endOfFirst + 1, endOfSecond);
|
|
} else endOfFirst = error;
|
|
error = v8FrameRegExp.exec(endOfFirst);
|
|
if (
|
|
!error &&
|
|
((error = jscSpiderMonkeyFrameRegExp.exec(endOfFirst)), !error)
|
|
)
|
|
return null;
|
|
endOfFirst = error[1] || "";
|
|
"<anonymous>" === endOfFirst && (endOfFirst = "");
|
|
endOfSecond = error[2] || error[5] || "";
|
|
"<anonymous>" === endOfSecond && (endOfSecond = "");
|
|
return [
|
|
endOfFirst,
|
|
endOfSecond,
|
|
+(error[3] || error[6]),
|
|
+(error[4] || error[7])
|
|
];
|
|
}
|
|
function getComponentNameFromType(type) {
|
|
if (null == type) return null;
|
|
if ("function" === typeof type)
|
|
return type.$$typeof === REACT_CLIENT_REFERENCE
|
|
? null
|
|
: type.displayName || type.name || null;
|
|
if ("string" === typeof type) return type;
|
|
switch (type) {
|
|
case REACT_FRAGMENT_TYPE:
|
|
return "Fragment";
|
|
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_ACTIVITY_TYPE:
|
|
return "Activity";
|
|
case REACT_VIEW_TRANSITION_TYPE:
|
|
return "ViewTransition";
|
|
}
|
|
if ("object" === typeof type)
|
|
switch (
|
|
("number" === typeof type.tag &&
|
|
console.error(
|
|
"Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
|
|
),
|
|
type.$$typeof)
|
|
) {
|
|
case REACT_PORTAL_TYPE:
|
|
return "Portal";
|
|
case REACT_CONTEXT_TYPE:
|
|
return type.displayName || "Context";
|
|
case REACT_CONSUMER_TYPE:
|
|
return (type._context.displayName || "Context") + ".Consumer";
|
|
case REACT_FORWARD_REF_TYPE:
|
|
var innerType = type.render;
|
|
type = type.displayName;
|
|
type ||
|
|
((type = innerType.displayName || innerType.name || ""),
|
|
(type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
|
|
return type;
|
|
case REACT_MEMO_TYPE:
|
|
return (
|
|
(innerType = type.displayName || null),
|
|
null !== innerType
|
|
? innerType
|
|
: getComponentNameFromType(type.type) || "Memo"
|
|
);
|
|
case REACT_LAZY_TYPE:
|
|
innerType = type._payload;
|
|
type = type._init;
|
|
try {
|
|
return getComponentNameFromType(type(innerType));
|
|
} catch (x) {}
|
|
}
|
|
return null;
|
|
}
|
|
function getArrayKind(array) {
|
|
for (var kind = 0, i = 0; i < array.length && 100 > i; i++) {
|
|
var value = array[i];
|
|
if ("object" === typeof value && null !== value)
|
|
if (
|
|
isArrayImpl(value) &&
|
|
2 === value.length &&
|
|
"string" === typeof value[0]
|
|
) {
|
|
if (0 !== kind && 3 !== kind) return 1;
|
|
kind = 3;
|
|
} else return 1;
|
|
else {
|
|
if (
|
|
"function" === typeof value ||
|
|
("string" === typeof value && 50 < value.length) ||
|
|
(0 !== kind && 2 !== kind)
|
|
)
|
|
return 1;
|
|
kind = 2;
|
|
}
|
|
}
|
|
return kind;
|
|
}
|
|
function addObjectToProperties(object, properties, indent, prefix) {
|
|
var addedProperties = 0,
|
|
key;
|
|
for (key in object)
|
|
if (
|
|
hasOwnProperty.call(object, key) &&
|
|
"_" !== key[0] &&
|
|
(addedProperties++,
|
|
addValueToProperties(key, object[key], properties, indent, prefix),
|
|
100 <= addedProperties)
|
|
) {
|
|
properties.push([
|
|
prefix +
|
|
"\u00a0\u00a0".repeat(indent) +
|
|
"Only 100 properties are shown. React will not log more properties of this object.",
|
|
""
|
|
]);
|
|
break;
|
|
}
|
|
}
|
|
function addValueToProperties(
|
|
propertyName,
|
|
value,
|
|
properties,
|
|
indent,
|
|
prefix
|
|
) {
|
|
switch (typeof value) {
|
|
case "object":
|
|
if (null === value) {
|
|
value = "null";
|
|
break;
|
|
} else {
|
|
if (value.$$typeof === REACT_ELEMENT_TYPE) {
|
|
var typeName = getComponentNameFromType(value.type) || "\u2026",
|
|
key = value.key;
|
|
value = value.props;
|
|
var propsKeys = Object.keys(value),
|
|
propsLength = propsKeys.length;
|
|
if (null == key && 0 === propsLength) {
|
|
value = "<" + typeName + " />";
|
|
break;
|
|
}
|
|
if (
|
|
3 > indent ||
|
|
(1 === propsLength &&
|
|
"children" === propsKeys[0] &&
|
|
null == key)
|
|
) {
|
|
value = "<" + typeName + " \u2026 />";
|
|
break;
|
|
}
|
|
properties.push([
|
|
prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
|
|
"<" + typeName
|
|
]);
|
|
null !== key &&
|
|
addValueToProperties(
|
|
"key",
|
|
key,
|
|
properties,
|
|
indent + 1,
|
|
prefix
|
|
);
|
|
propertyName = !1;
|
|
key = 0;
|
|
for (var propKey in value)
|
|
if (
|
|
(key++,
|
|
"children" === propKey
|
|
? null != value.children &&
|
|
(!isArrayImpl(value.children) ||
|
|
0 < value.children.length) &&
|
|
(propertyName = !0)
|
|
: hasOwnProperty.call(value, propKey) &&
|
|
"_" !== propKey[0] &&
|
|
addValueToProperties(
|
|
propKey,
|
|
value[propKey],
|
|
properties,
|
|
indent + 1,
|
|
prefix
|
|
),
|
|
100 <= key)
|
|
)
|
|
break;
|
|
properties.push([
|
|
"",
|
|
propertyName ? ">\u2026</" + typeName + ">" : "/>"
|
|
]);
|
|
return;
|
|
}
|
|
typeName = Object.prototype.toString.call(value);
|
|
propKey = typeName.slice(8, typeName.length - 1);
|
|
if ("Array" === propKey)
|
|
if (
|
|
((typeName = 100 < value.length),
|
|
(key = getArrayKind(value)),
|
|
2 === key || 0 === key)
|
|
) {
|
|
value = JSON.stringify(
|
|
typeName ? value.slice(0, 100).concat("\u2026") : value
|
|
);
|
|
break;
|
|
} else if (3 === key) {
|
|
properties.push([
|
|
prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
|
|
""
|
|
]);
|
|
for (
|
|
propertyName = 0;
|
|
propertyName < value.length && 100 > propertyName;
|
|
propertyName++
|
|
)
|
|
(propKey = value[propertyName]),
|
|
addValueToProperties(
|
|
propKey[0],
|
|
propKey[1],
|
|
properties,
|
|
indent + 1,
|
|
prefix
|
|
);
|
|
typeName &&
|
|
addValueToProperties(
|
|
(100).toString(),
|
|
"\u2026",
|
|
properties,
|
|
indent + 1,
|
|
prefix
|
|
);
|
|
return;
|
|
}
|
|
if ("Promise" === propKey) {
|
|
if ("fulfilled" === value.status) {
|
|
if (
|
|
((typeName = properties.length),
|
|
addValueToProperties(
|
|
propertyName,
|
|
value.value,
|
|
properties,
|
|
indent,
|
|
prefix
|
|
),
|
|
properties.length > typeName)
|
|
) {
|
|
properties = properties[typeName];
|
|
properties[1] =
|
|
"Promise<" + (properties[1] || "Object") + ">";
|
|
return;
|
|
}
|
|
} else if (
|
|
"rejected" === value.status &&
|
|
((typeName = properties.length),
|
|
addValueToProperties(
|
|
propertyName,
|
|
value.reason,
|
|
properties,
|
|
indent,
|
|
prefix
|
|
),
|
|
properties.length > typeName)
|
|
) {
|
|
properties = properties[typeName];
|
|
properties[1] = "Rejected Promise<" + properties[1] + ">";
|
|
return;
|
|
}
|
|
properties.push([
|
|
"\u00a0\u00a0".repeat(indent) + propertyName,
|
|
"Promise"
|
|
]);
|
|
return;
|
|
}
|
|
"Object" === propKey &&
|
|
(typeName = Object.getPrototypeOf(value)) &&
|
|
"function" === typeof typeName.constructor &&
|
|
(propKey = typeName.constructor.name);
|
|
properties.push([
|
|
prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
|
|
"Object" === propKey ? (3 > indent ? "" : "\u2026") : propKey
|
|
]);
|
|
3 > indent &&
|
|
addObjectToProperties(value, properties, indent + 1, prefix);
|
|
return;
|
|
}
|
|
case "function":
|
|
value = "" === value.name ? "() => {}" : value.name + "() {}";
|
|
break;
|
|
case "string":
|
|
value =
|
|
"This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects." ===
|
|
value
|
|
? "\u2026"
|
|
: JSON.stringify(value);
|
|
break;
|
|
case "undefined":
|
|
value = "undefined";
|
|
break;
|
|
case "boolean":
|
|
value = value ? "true" : "false";
|
|
break;
|
|
default:
|
|
value = String(value);
|
|
}
|
|
properties.push([
|
|
prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
|
|
value
|
|
]);
|
|
}
|
|
function getIODescription(value) {
|
|
try {
|
|
switch (typeof value) {
|
|
case "function":
|
|
return value.name || "";
|
|
case "object":
|
|
if (null === value) return "";
|
|
if (value instanceof Error) return String(value.message);
|
|
if ("string" === typeof value.url) return value.url;
|
|
if ("string" === typeof value.href) return value.href;
|
|
if ("string" === typeof value.src) return value.src;
|
|
if ("string" === typeof value.currentSrc) return value.currentSrc;
|
|
if ("string" === typeof value.command) return value.command;
|
|
if (
|
|
"object" === typeof value.request &&
|
|
null !== value.request &&
|
|
"string" === typeof value.request.url
|
|
)
|
|
return value.request.url;
|
|
if (
|
|
"object" === typeof value.response &&
|
|
null !== value.response &&
|
|
"string" === typeof value.response.url
|
|
)
|
|
return value.response.url;
|
|
if (
|
|
"string" === typeof value.id ||
|
|
"number" === typeof value.id ||
|
|
"bigint" === typeof value.id
|
|
)
|
|
return String(value.id);
|
|
if ("string" === typeof value.name) return value.name;
|
|
var str = value.toString();
|
|
return str.startsWith("[object ") ||
|
|
5 > str.length ||
|
|
500 < str.length
|
|
? ""
|
|
: str;
|
|
case "string":
|
|
return 5 > value.length || 500 < value.length ? "" : value;
|
|
case "number":
|
|
case "bigint":
|
|
return String(value);
|
|
default:
|
|
return "";
|
|
}
|
|
} catch (x) {
|
|
return "";
|
|
}
|
|
}
|
|
function markAllTracksInOrder() {
|
|
supportsUserTiming &&
|
|
(console.timeStamp(
|
|
"Server Requests Track",
|
|
0.001,
|
|
0.001,
|
|
"Server Requests \u269b",
|
|
void 0,
|
|
"primary-light"
|
|
),
|
|
console.timeStamp(
|
|
"Server Components Track",
|
|
0.001,
|
|
0.001,
|
|
"Primary",
|
|
"Server Components \u269b",
|
|
"primary-light"
|
|
));
|
|
}
|
|
function getIOColor(functionName) {
|
|
switch (functionName.charCodeAt(0) % 3) {
|
|
case 0:
|
|
return "tertiary-light";
|
|
case 1:
|
|
return "tertiary";
|
|
default:
|
|
return "tertiary-dark";
|
|
}
|
|
}
|
|
function getIOLongName(ioInfo, description, env, rootEnv) {
|
|
ioInfo = ioInfo.name;
|
|
description =
|
|
"" === description ? ioInfo : ioInfo + " (" + description + ")";
|
|
return env === rootEnv || void 0 === env
|
|
? description
|
|
: description + " [" + env + "]";
|
|
}
|
|
function getIOShortName(ioInfo, description, env, rootEnv) {
|
|
ioInfo = ioInfo.name;
|
|
env = env === rootEnv || void 0 === env ? "" : " [" + env + "]";
|
|
var desc = "";
|
|
rootEnv = 30 - ioInfo.length - env.length;
|
|
if (1 < rootEnv) {
|
|
var l = description.length;
|
|
if (0 < l && l <= rootEnv) desc = " (" + description + ")";
|
|
else if (
|
|
description.startsWith("http://") ||
|
|
description.startsWith("https://") ||
|
|
description.startsWith("/")
|
|
) {
|
|
var queryIdx = description.indexOf("?");
|
|
-1 === queryIdx && (queryIdx = description.length);
|
|
47 === description.charCodeAt(queryIdx - 1) && queryIdx--;
|
|
desc = description.lastIndexOf("/", queryIdx - 1);
|
|
queryIdx - desc < rootEnv
|
|
? (desc = " (\u2026" + description.slice(desc, queryIdx) + ")")
|
|
: ((l = description.slice(desc, desc + rootEnv / 2)),
|
|
(description = description.slice(
|
|
queryIdx - rootEnv / 2,
|
|
queryIdx
|
|
)),
|
|
(desc =
|
|
" (" +
|
|
(0 < desc ? "\u2026" : "") +
|
|
l +
|
|
"\u2026" +
|
|
description +
|
|
")"));
|
|
}
|
|
}
|
|
return ioInfo + desc + env;
|
|
}
|
|
function logComponentAwait(
|
|
asyncInfo,
|
|
trackIdx,
|
|
startTime,
|
|
endTime,
|
|
rootEnv,
|
|
value
|
|
) {
|
|
if (supportsUserTiming && 0 < endTime) {
|
|
var description = getIODescription(value),
|
|
name = getIOShortName(
|
|
asyncInfo.awaited,
|
|
description,
|
|
asyncInfo.env,
|
|
rootEnv
|
|
),
|
|
entryName = "await " + name;
|
|
name = getIOColor(name);
|
|
var debugTask = asyncInfo.debugTask || asyncInfo.awaited.debugTask;
|
|
if (debugTask) {
|
|
var properties = [];
|
|
"object" === typeof value && null !== value
|
|
? addObjectToProperties(value, properties, 0, "")
|
|
: void 0 !== value &&
|
|
addValueToProperties("awaited value", value, properties, 0, "");
|
|
asyncInfo = getIOLongName(
|
|
asyncInfo.awaited,
|
|
description,
|
|
asyncInfo.env,
|
|
rootEnv
|
|
);
|
|
debugTask.run(
|
|
performance.measure.bind(performance, entryName, {
|
|
start: 0 > startTime ? 0 : startTime,
|
|
end: endTime,
|
|
detail: {
|
|
devtools: {
|
|
color: name,
|
|
track: trackNames[trackIdx],
|
|
trackGroup: "Server Components \u269b",
|
|
properties: properties,
|
|
tooltipText: asyncInfo
|
|
}
|
|
}
|
|
})
|
|
);
|
|
performance.clearMeasures(entryName);
|
|
} else
|
|
console.timeStamp(
|
|
entryName,
|
|
0 > startTime ? 0 : startTime,
|
|
endTime,
|
|
trackNames[trackIdx],
|
|
"Server Components \u269b",
|
|
name
|
|
);
|
|
}
|
|
}
|
|
function logIOInfoErrored(ioInfo, rootEnv, error) {
|
|
var startTime = ioInfo.start,
|
|
endTime = ioInfo.end;
|
|
if (supportsUserTiming && 0 <= endTime) {
|
|
var description = getIODescription(error),
|
|
entryName = getIOShortName(ioInfo, description, ioInfo.env, rootEnv),
|
|
debugTask = ioInfo.debugTask;
|
|
entryName = "\u200b" + entryName;
|
|
debugTask
|
|
? ((error = [
|
|
[
|
|
"rejected with",
|
|
"object" === typeof error &&
|
|
null !== error &&
|
|
"string" === typeof error.message
|
|
? String(error.message)
|
|
: String(error)
|
|
]
|
|
]),
|
|
(ioInfo =
|
|
getIOLongName(ioInfo, description, ioInfo.env, rootEnv) +
|
|
" Rejected"),
|
|
debugTask.run(
|
|
performance.measure.bind(performance, entryName, {
|
|
start: 0 > startTime ? 0 : startTime,
|
|
end: endTime,
|
|
detail: {
|
|
devtools: {
|
|
color: "error",
|
|
track: "Server Requests \u269b",
|
|
properties: error,
|
|
tooltipText: ioInfo
|
|
}
|
|
}
|
|
})
|
|
),
|
|
performance.clearMeasures(entryName))
|
|
: console.timeStamp(
|
|
entryName,
|
|
0 > startTime ? 0 : startTime,
|
|
endTime,
|
|
"Server Requests \u269b",
|
|
void 0,
|
|
"error"
|
|
);
|
|
}
|
|
}
|
|
function logIOInfo(ioInfo, rootEnv, value) {
|
|
var startTime = ioInfo.start,
|
|
endTime = ioInfo.end;
|
|
if (supportsUserTiming && 0 <= endTime) {
|
|
var description = getIODescription(value),
|
|
entryName = getIOShortName(ioInfo, description, ioInfo.env, rootEnv),
|
|
color = getIOColor(entryName),
|
|
debugTask = ioInfo.debugTask;
|
|
entryName = "\u200b" + entryName;
|
|
if (debugTask) {
|
|
var properties = [];
|
|
"object" === typeof value && null !== value
|
|
? addObjectToProperties(value, properties, 0, "")
|
|
: void 0 !== value &&
|
|
addValueToProperties("Resolved", value, properties, 0, "");
|
|
ioInfo = getIOLongName(ioInfo, description, ioInfo.env, rootEnv);
|
|
debugTask.run(
|
|
performance.measure.bind(performance, entryName, {
|
|
start: 0 > startTime ? 0 : startTime,
|
|
end: endTime,
|
|
detail: {
|
|
devtools: {
|
|
color: color,
|
|
track: "Server Requests \u269b",
|
|
properties: properties,
|
|
tooltipText: ioInfo
|
|
}
|
|
}
|
|
})
|
|
);
|
|
performance.clearMeasures(entryName);
|
|
} else
|
|
console.timeStamp(
|
|
entryName,
|
|
0 > startTime ? 0 : startTime,
|
|
endTime,
|
|
"Server Requests \u269b",
|
|
void 0,
|
|
color
|
|
);
|
|
}
|
|
}
|
|
function ReactPromise(status, value, reason) {
|
|
this.status = status;
|
|
this.value = value;
|
|
this.reason = reason;
|
|
this._children = [];
|
|
this._debugChunk = null;
|
|
this._debugInfo = [];
|
|
}
|
|
function unwrapWeakResponse(weakResponse) {
|
|
weakResponse = weakResponse.weak.deref();
|
|
if (void 0 === weakResponse)
|
|
throw Error(
|
|
"We did not expect to receive new data after GC:ing the response."
|
|
);
|
|
return weakResponse;
|
|
}
|
|
function closeDebugChannel(debugChannel) {
|
|
debugChannel.callback && debugChannel.callback("");
|
|
}
|
|
function readChunk(chunk) {
|
|
switch (chunk.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(chunk);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(chunk);
|
|
}
|
|
switch (chunk.status) {
|
|
case "fulfilled":
|
|
return chunk.value;
|
|
case "pending":
|
|
case "blocked":
|
|
case "halted":
|
|
throw chunk;
|
|
default:
|
|
throw chunk.reason;
|
|
}
|
|
}
|
|
function getRoot(weakResponse) {
|
|
weakResponse = unwrapWeakResponse(weakResponse);
|
|
return getChunk(weakResponse, 0);
|
|
}
|
|
function createPendingChunk(response) {
|
|
0 === response._pendingChunks++ &&
|
|
((response._weakResponse.response = response),
|
|
null !== response._pendingInitialRender &&
|
|
(clearTimeout(response._pendingInitialRender),
|
|
(response._pendingInitialRender = null)));
|
|
return new ReactPromise("pending", null, null);
|
|
}
|
|
function releasePendingChunk(response, chunk) {
|
|
"pending" === chunk.status &&
|
|
0 === --response._pendingChunks &&
|
|
((response._weakResponse.response = null),
|
|
(response._pendingInitialRender = setTimeout(
|
|
flushInitialRenderPerformance.bind(null, response),
|
|
100
|
|
)));
|
|
}
|
|
function filterDebugInfo(response, value) {
|
|
if (null !== response._debugEndTime) {
|
|
response = response._debugEndTime - performance.timeOrigin;
|
|
for (var debugInfo = [], i = 0; i < value._debugInfo.length; i++) {
|
|
var info = value._debugInfo[i];
|
|
if ("number" === typeof info.time && info.time > response) break;
|
|
debugInfo.push(info);
|
|
}
|
|
value._debugInfo = debugInfo;
|
|
}
|
|
}
|
|
function moveDebugInfoFromChunkToInnerValue(chunk, value) {
|
|
value = resolveLazy(value);
|
|
"object" !== typeof value ||
|
|
null === value ||
|
|
(!isArrayImpl(value) &&
|
|
"function" !== typeof value[ASYNC_ITERATOR] &&
|
|
value.$$typeof !== REACT_ELEMENT_TYPE &&
|
|
value.$$typeof !== REACT_LAZY_TYPE) ||
|
|
((chunk = chunk._debugInfo.splice(0)),
|
|
isArrayImpl(value._debugInfo)
|
|
? value._debugInfo.unshift.apply(value._debugInfo, chunk)
|
|
: Object.defineProperty(value, "_debugInfo", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: chunk
|
|
}));
|
|
}
|
|
function wakeChunk(response, listeners, value, chunk) {
|
|
for (var i = 0; i < listeners.length; i++) {
|
|
var listener = listeners[i];
|
|
"function" === typeof listener
|
|
? listener(value)
|
|
: fulfillReference(response, listener, value, chunk);
|
|
}
|
|
filterDebugInfo(response, chunk);
|
|
moveDebugInfoFromChunkToInnerValue(chunk, value);
|
|
}
|
|
function rejectChunk(response, listeners, error) {
|
|
for (var i = 0; i < listeners.length; i++) {
|
|
var listener = listeners[i];
|
|
"function" === typeof listener
|
|
? listener(error)
|
|
: rejectReference(response, listener.handler, error);
|
|
}
|
|
}
|
|
function resolveBlockedCycle(resolvedChunk, reference) {
|
|
var referencedChunk = reference.handler.chunk;
|
|
if (null === referencedChunk) return null;
|
|
if (referencedChunk === resolvedChunk) return reference.handler;
|
|
reference = referencedChunk.value;
|
|
if (null !== reference)
|
|
for (
|
|
referencedChunk = 0;
|
|
referencedChunk < reference.length;
|
|
referencedChunk++
|
|
) {
|
|
var listener = reference[referencedChunk];
|
|
if (
|
|
"function" !== typeof listener &&
|
|
((listener = resolveBlockedCycle(resolvedChunk, listener)),
|
|
null !== listener)
|
|
)
|
|
return listener;
|
|
}
|
|
return null;
|
|
}
|
|
function wakeChunkIfInitialized(
|
|
response,
|
|
chunk,
|
|
resolveListeners,
|
|
rejectListeners
|
|
) {
|
|
switch (chunk.status) {
|
|
case "fulfilled":
|
|
wakeChunk(response, resolveListeners, chunk.value, chunk);
|
|
break;
|
|
case "blocked":
|
|
for (var i = 0; i < resolveListeners.length; i++) {
|
|
var listener = resolveListeners[i];
|
|
if ("function" !== typeof listener) {
|
|
var cyclicHandler = resolveBlockedCycle(chunk, listener);
|
|
if (null !== cyclicHandler)
|
|
switch (
|
|
(fulfillReference(
|
|
response,
|
|
listener,
|
|
cyclicHandler.value,
|
|
chunk
|
|
),
|
|
resolveListeners.splice(i, 1),
|
|
i--,
|
|
null !== rejectListeners &&
|
|
((listener = rejectListeners.indexOf(listener)),
|
|
-1 !== listener && rejectListeners.splice(listener, 1)),
|
|
chunk.status)
|
|
) {
|
|
case "fulfilled":
|
|
wakeChunk(response, resolveListeners, chunk.value, chunk);
|
|
return;
|
|
case "rejected":
|
|
null !== rejectListeners &&
|
|
rejectChunk(response, rejectListeners, chunk.reason);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
case "pending":
|
|
if (chunk.value)
|
|
for (response = 0; response < resolveListeners.length; response++)
|
|
chunk.value.push(resolveListeners[response]);
|
|
else chunk.value = resolveListeners;
|
|
if (chunk.reason) {
|
|
if (rejectListeners)
|
|
for (
|
|
resolveListeners = 0;
|
|
resolveListeners < rejectListeners.length;
|
|
resolveListeners++
|
|
)
|
|
chunk.reason.push(rejectListeners[resolveListeners]);
|
|
} else chunk.reason = rejectListeners;
|
|
break;
|
|
case "rejected":
|
|
rejectListeners &&
|
|
rejectChunk(response, rejectListeners, chunk.reason);
|
|
}
|
|
}
|
|
function triggerErrorOnChunk(response, chunk, error) {
|
|
if ("pending" !== chunk.status && "blocked" !== chunk.status)
|
|
chunk.reason.error(error);
|
|
else {
|
|
releasePendingChunk(response, chunk);
|
|
var listeners = chunk.reason;
|
|
if ("pending" === chunk.status && null != chunk._debugChunk) {
|
|
var prevHandler = initializingHandler,
|
|
prevChunk = initializingChunk;
|
|
initializingHandler = null;
|
|
chunk.status = "blocked";
|
|
chunk.value = null;
|
|
chunk.reason = null;
|
|
initializingChunk = chunk;
|
|
try {
|
|
initializeDebugChunk(response, chunk);
|
|
} finally {
|
|
(initializingHandler = prevHandler),
|
|
(initializingChunk = prevChunk);
|
|
}
|
|
}
|
|
chunk.status = "rejected";
|
|
chunk.reason = error;
|
|
null !== listeners && rejectChunk(response, listeners, error);
|
|
}
|
|
}
|
|
function createResolvedModelChunk(response, value) {
|
|
return new ReactPromise("resolved_model", value, response);
|
|
}
|
|
function createResolvedIteratorResultChunk(response, value, done) {
|
|
return new ReactPromise(
|
|
"resolved_model",
|
|
(done ? '{"done":true,"value":' : '{"done":false,"value":') +
|
|
value +
|
|
"}",
|
|
response
|
|
);
|
|
}
|
|
function resolveIteratorResultChunk(response, chunk, value, done) {
|
|
resolveModelChunk(
|
|
response,
|
|
chunk,
|
|
(done ? '{"done":true,"value":' : '{"done":false,"value":') +
|
|
value +
|
|
"}"
|
|
);
|
|
}
|
|
function resolveModelChunk(response, chunk, value) {
|
|
if ("pending" !== chunk.status) chunk.reason.enqueueModel(value);
|
|
else {
|
|
releasePendingChunk(response, chunk);
|
|
var resolveListeners = chunk.value,
|
|
rejectListeners = chunk.reason;
|
|
chunk.status = "resolved_model";
|
|
chunk.value = value;
|
|
chunk.reason = response;
|
|
null !== resolveListeners &&
|
|
(initializeModelChunk(chunk),
|
|
wakeChunkIfInitialized(
|
|
response,
|
|
chunk,
|
|
resolveListeners,
|
|
rejectListeners
|
|
));
|
|
}
|
|
}
|
|
function resolveModuleChunk(response, chunk, value) {
|
|
if ("pending" === chunk.status || "blocked" === chunk.status) {
|
|
releasePendingChunk(response, chunk);
|
|
var resolveListeners = chunk.value,
|
|
rejectListeners = chunk.reason;
|
|
chunk.status = "resolved_module";
|
|
chunk.value = value;
|
|
chunk.reason = null;
|
|
value = value[1];
|
|
for (var debugInfo = [], i = 0; i < value.length; ) {
|
|
var chunkId = value[i++];
|
|
value[i++];
|
|
var href = void 0,
|
|
target = debugInfo,
|
|
ioInfo = chunkIOInfoCache.get(chunkId);
|
|
if (void 0 === ioInfo) {
|
|
var scriptFilename = __webpack_get_script_filename__(chunkId);
|
|
try {
|
|
href = new URL(scriptFilename, document.baseURI).href;
|
|
} catch (_) {
|
|
href = scriptFilename;
|
|
}
|
|
var end = (ioInfo = -1);
|
|
scriptFilename = 0;
|
|
if ("function" === typeof performance.getEntriesByType)
|
|
for (
|
|
var resourceEntries = performance.getEntriesByType("resource"),
|
|
i$jscomp$0 = 0;
|
|
i$jscomp$0 < resourceEntries.length;
|
|
i$jscomp$0++
|
|
) {
|
|
var resourceEntry = resourceEntries[i$jscomp$0];
|
|
resourceEntry.name === href &&
|
|
((ioInfo = resourceEntry.startTime),
|
|
(end = ioInfo + resourceEntry.duration),
|
|
(scriptFilename = resourceEntry.transferSize || 0));
|
|
}
|
|
resourceEntries = Promise.resolve(href);
|
|
resourceEntries.status = "fulfilled";
|
|
resourceEntries.value = { chunkId: chunkId, href: href };
|
|
i$jscomp$0 = Error("react-stack-top-frame");
|
|
i$jscomp$0.stack.startsWith("Error: react-stack-top-frame")
|
|
? (i$jscomp$0.stack =
|
|
"Error: react-stack-top-frame\n at Client Component Bundle (" +
|
|
href +
|
|
":1:1)\n at Client Component Bundle (" +
|
|
href +
|
|
":1:1)")
|
|
: (i$jscomp$0.stack =
|
|
"Client Component Bundle@" +
|
|
href +
|
|
":1:1\nClient Component Bundle@" +
|
|
href +
|
|
":1:1");
|
|
ioInfo = {
|
|
name: "script",
|
|
start: ioInfo,
|
|
end: end,
|
|
value: resourceEntries,
|
|
debugStack: i$jscomp$0
|
|
};
|
|
0 < scriptFilename && (ioInfo.byteSize = scriptFilename);
|
|
chunkIOInfoCache.set(chunkId, ioInfo);
|
|
}
|
|
target.push({ awaited: ioInfo });
|
|
}
|
|
null !== debugInfo &&
|
|
chunk._debugInfo.push.apply(chunk._debugInfo, debugInfo);
|
|
null !== resolveListeners &&
|
|
(initializeModuleChunk(chunk),
|
|
wakeChunkIfInitialized(
|
|
response,
|
|
chunk,
|
|
resolveListeners,
|
|
rejectListeners
|
|
));
|
|
}
|
|
}
|
|
function initializeDebugChunk(response, chunk) {
|
|
var debugChunk = chunk._debugChunk;
|
|
if (null !== debugChunk) {
|
|
var debugInfo = chunk._debugInfo;
|
|
try {
|
|
if ("resolved_model" === debugChunk.status) {
|
|
for (
|
|
var idx = debugInfo.length, c = debugChunk._debugChunk;
|
|
null !== c;
|
|
|
|
)
|
|
"fulfilled" !== c.status && idx++, (c = c._debugChunk);
|
|
initializeModelChunk(debugChunk);
|
|
switch (debugChunk.status) {
|
|
case "fulfilled":
|
|
debugInfo[idx] = initializeDebugInfo(
|
|
response,
|
|
debugChunk.value
|
|
);
|
|
break;
|
|
case "blocked":
|
|
case "pending":
|
|
waitForReference(
|
|
debugChunk,
|
|
debugInfo,
|
|
"" + idx,
|
|
response,
|
|
initializeDebugInfo,
|
|
[""],
|
|
!0
|
|
);
|
|
break;
|
|
default:
|
|
throw debugChunk.reason;
|
|
}
|
|
} else
|
|
switch (debugChunk.status) {
|
|
case "fulfilled":
|
|
break;
|
|
case "blocked":
|
|
case "pending":
|
|
waitForReference(
|
|
debugChunk,
|
|
{},
|
|
"debug",
|
|
response,
|
|
initializeDebugInfo,
|
|
[""],
|
|
!0
|
|
);
|
|
break;
|
|
default:
|
|
throw debugChunk.reason;
|
|
}
|
|
} catch (error) {
|
|
triggerErrorOnChunk(response, chunk, error);
|
|
}
|
|
}
|
|
}
|
|
function initializeModelChunk(chunk) {
|
|
var prevHandler = initializingHandler,
|
|
prevChunk = initializingChunk;
|
|
initializingHandler = null;
|
|
var resolvedModel = chunk.value,
|
|
response = chunk.reason;
|
|
chunk.status = "blocked";
|
|
chunk.value = null;
|
|
chunk.reason = null;
|
|
initializingChunk = chunk;
|
|
initializeDebugChunk(response, chunk);
|
|
try {
|
|
var value = JSON.parse(resolvedModel, response._fromJSON),
|
|
resolveListeners = chunk.value;
|
|
if (null !== resolveListeners)
|
|
for (
|
|
chunk.value = null, chunk.reason = null, resolvedModel = 0;
|
|
resolvedModel < resolveListeners.length;
|
|
resolvedModel++
|
|
) {
|
|
var listener = resolveListeners[resolvedModel];
|
|
"function" === typeof listener
|
|
? listener(value)
|
|
: fulfillReference(response, listener, value, chunk);
|
|
}
|
|
if (null !== initializingHandler) {
|
|
if (initializingHandler.errored) throw initializingHandler.reason;
|
|
if (0 < initializingHandler.deps) {
|
|
initializingHandler.value = value;
|
|
initializingHandler.chunk = chunk;
|
|
return;
|
|
}
|
|
}
|
|
chunk.status = "fulfilled";
|
|
chunk.value = value;
|
|
filterDebugInfo(response, chunk);
|
|
moveDebugInfoFromChunkToInnerValue(chunk, value);
|
|
} catch (error) {
|
|
(chunk.status = "rejected"), (chunk.reason = error);
|
|
} finally {
|
|
(initializingHandler = prevHandler), (initializingChunk = prevChunk);
|
|
}
|
|
}
|
|
function initializeModuleChunk(chunk) {
|
|
try {
|
|
var value = requireModule(chunk.value);
|
|
chunk.status = "fulfilled";
|
|
chunk.value = value;
|
|
} catch (error) {
|
|
(chunk.status = "rejected"), (chunk.reason = error);
|
|
}
|
|
}
|
|
function reportGlobalError(weakResponse, error) {
|
|
if (void 0 !== weakResponse.weak.deref()) {
|
|
var response = unwrapWeakResponse(weakResponse);
|
|
response._closed = !0;
|
|
response._closedReason = error;
|
|
response._chunks.forEach(function (chunk) {
|
|
"pending" === chunk.status
|
|
? triggerErrorOnChunk(response, chunk, error)
|
|
: "fulfilled" === chunk.status &&
|
|
null !== chunk.reason &&
|
|
chunk.reason.error(error);
|
|
});
|
|
weakResponse = response._debugChannel;
|
|
void 0 !== weakResponse &&
|
|
(closeDebugChannel(weakResponse),
|
|
(response._debugChannel = void 0),
|
|
null !== debugChannelRegistry &&
|
|
debugChannelRegistry.unregister(response));
|
|
}
|
|
}
|
|
function nullRefGetter() {
|
|
return null;
|
|
}
|
|
function getTaskName(type) {
|
|
if (type === REACT_FRAGMENT_TYPE) return "<>";
|
|
if ("function" === typeof type) return '"use client"';
|
|
if (
|
|
"object" === typeof type &&
|
|
null !== type &&
|
|
type.$$typeof === REACT_LAZY_TYPE
|
|
)
|
|
return type._init === readChunk ? '"use client"' : "<...>";
|
|
try {
|
|
var name = getComponentNameFromType(type);
|
|
return name ? "<" + name + ">" : "<...>";
|
|
} catch (x) {
|
|
return "<...>";
|
|
}
|
|
}
|
|
function initializeElement(response, element, lazyNode) {
|
|
var stack = element._debugStack,
|
|
owner = element._owner;
|
|
null === owner && (element._owner = response._debugRootOwner);
|
|
var env = response._rootEnvironmentName;
|
|
null !== owner && null != owner.env && (env = owner.env);
|
|
var normalizedStackTrace = null;
|
|
null === owner && null != response._debugRootStack
|
|
? (normalizedStackTrace = response._debugRootStack)
|
|
: null !== stack &&
|
|
(normalizedStackTrace = createFakeJSXCallStackInDEV(
|
|
response,
|
|
stack,
|
|
env
|
|
));
|
|
element._debugStack = normalizedStackTrace;
|
|
normalizedStackTrace = null;
|
|
supportsCreateTask &&
|
|
null !== stack &&
|
|
((normalizedStackTrace = console.createTask.bind(
|
|
console,
|
|
getTaskName(element.type)
|
|
)),
|
|
(stack = buildFakeCallStack(
|
|
response,
|
|
stack,
|
|
env,
|
|
!1,
|
|
normalizedStackTrace
|
|
)),
|
|
(env = null === owner ? null : initializeFakeTask(response, owner)),
|
|
null === env
|
|
? ((env = response._debugRootTask),
|
|
(normalizedStackTrace = null != env ? env.run(stack) : stack()))
|
|
: (normalizedStackTrace = env.run(stack)));
|
|
element._debugTask = normalizedStackTrace;
|
|
null !== owner && initializeFakeStack(response, owner);
|
|
null !== lazyNode &&
|
|
(lazyNode._store &&
|
|
lazyNode._store.validated &&
|
|
!element._store.validated &&
|
|
(element._store.validated = lazyNode._store.validated),
|
|
"fulfilled" === lazyNode._payload.status &&
|
|
lazyNode._debugInfo &&
|
|
((response = lazyNode._debugInfo.splice(0)),
|
|
element._debugInfo
|
|
? element._debugInfo.unshift.apply(element._debugInfo, response)
|
|
: Object.defineProperty(element, "_debugInfo", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: response
|
|
})));
|
|
Object.freeze(element.props);
|
|
}
|
|
function createLazyChunkWrapper(chunk, validated) {
|
|
var lazyType = {
|
|
$$typeof: REACT_LAZY_TYPE,
|
|
_payload: chunk,
|
|
_init: readChunk
|
|
};
|
|
lazyType._debugInfo = chunk._debugInfo;
|
|
lazyType._store = { validated: validated };
|
|
return lazyType;
|
|
}
|
|
function getChunk(response, id) {
|
|
var chunks = response._chunks,
|
|
chunk = chunks.get(id);
|
|
chunk ||
|
|
((chunk = response._closed
|
|
? new ReactPromise("rejected", null, response._closedReason)
|
|
: createPendingChunk(response)),
|
|
chunks.set(id, chunk));
|
|
return chunk;
|
|
}
|
|
function fulfillReference(response, reference, value, fulfilledChunk) {
|
|
var handler = reference.handler,
|
|
parentObject = reference.parentObject,
|
|
key = reference.key,
|
|
map = reference.map,
|
|
path = reference.path;
|
|
try {
|
|
for (var i = 1; i < path.length; i++) {
|
|
for (
|
|
;
|
|
"object" === typeof value &&
|
|
null !== value &&
|
|
value.$$typeof === REACT_LAZY_TYPE;
|
|
|
|
) {
|
|
var referencedChunk = value._payload;
|
|
if (referencedChunk === handler.chunk) value = handler.value;
|
|
else {
|
|
switch (referencedChunk.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(referencedChunk);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(referencedChunk);
|
|
}
|
|
switch (referencedChunk.status) {
|
|
case "fulfilled":
|
|
value = referencedChunk.value;
|
|
continue;
|
|
case "blocked":
|
|
var cyclicHandler = resolveBlockedCycle(
|
|
referencedChunk,
|
|
reference
|
|
);
|
|
if (null !== cyclicHandler) {
|
|
value = cyclicHandler.value;
|
|
continue;
|
|
}
|
|
case "pending":
|
|
path.splice(0, i - 1);
|
|
null === referencedChunk.value
|
|
? (referencedChunk.value = [reference])
|
|
: referencedChunk.value.push(reference);
|
|
null === referencedChunk.reason
|
|
? (referencedChunk.reason = [reference])
|
|
: referencedChunk.reason.push(reference);
|
|
return;
|
|
case "halted":
|
|
return;
|
|
default:
|
|
rejectReference(
|
|
response,
|
|
reference.handler,
|
|
referencedChunk.reason
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
var name = path[i];
|
|
if (
|
|
"object" === typeof value &&
|
|
null !== value &&
|
|
hasOwnProperty.call(value, name)
|
|
)
|
|
value = value[name];
|
|
else throw Error("Invalid reference.");
|
|
}
|
|
for (
|
|
;
|
|
"object" === typeof value &&
|
|
null !== value &&
|
|
value.$$typeof === REACT_LAZY_TYPE;
|
|
|
|
) {
|
|
var _referencedChunk = value._payload;
|
|
if (_referencedChunk === handler.chunk) value = handler.value;
|
|
else {
|
|
switch (_referencedChunk.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(_referencedChunk);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(_referencedChunk);
|
|
}
|
|
switch (_referencedChunk.status) {
|
|
case "fulfilled":
|
|
value = _referencedChunk.value;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
var mappedValue = map(response, value, parentObject, key);
|
|
"__proto__" !== key && (parentObject[key] = mappedValue);
|
|
"" === key && null === handler.value && (handler.value = mappedValue);
|
|
if (
|
|
parentObject[0] === REACT_ELEMENT_TYPE &&
|
|
"object" === typeof handler.value &&
|
|
null !== handler.value &&
|
|
handler.value.$$typeof === REACT_ELEMENT_TYPE
|
|
) {
|
|
var element = handler.value;
|
|
switch (key) {
|
|
case "3":
|
|
transferReferencedDebugInfo(handler.chunk, fulfilledChunk);
|
|
element.props = mappedValue;
|
|
break;
|
|
case "4":
|
|
element._owner = mappedValue;
|
|
break;
|
|
case "5":
|
|
element._debugStack = mappedValue;
|
|
break;
|
|
default:
|
|
transferReferencedDebugInfo(handler.chunk, fulfilledChunk);
|
|
}
|
|
} else
|
|
reference.isDebug ||
|
|
transferReferencedDebugInfo(handler.chunk, fulfilledChunk);
|
|
} catch (error) {
|
|
rejectReference(response, reference.handler, error);
|
|
return;
|
|
}
|
|
handler.deps--;
|
|
0 === handler.deps &&
|
|
((reference = handler.chunk),
|
|
null !== reference &&
|
|
"blocked" === reference.status &&
|
|
((value = reference.value),
|
|
(reference.status = "fulfilled"),
|
|
(reference.value = handler.value),
|
|
(reference.reason = handler.reason),
|
|
null !== value
|
|
? wakeChunk(response, value, handler.value, reference)
|
|
: ((handler = handler.value),
|
|
filterDebugInfo(response, reference),
|
|
moveDebugInfoFromChunkToInnerValue(reference, handler))));
|
|
}
|
|
function rejectReference(response, handler, error) {
|
|
if (!handler.errored) {
|
|
var blockedValue = handler.value;
|
|
handler.errored = !0;
|
|
handler.value = null;
|
|
handler.reason = error;
|
|
handler = handler.chunk;
|
|
if (null !== handler && "blocked" === handler.status) {
|
|
if (
|
|
"object" === typeof blockedValue &&
|
|
null !== blockedValue &&
|
|
blockedValue.$$typeof === REACT_ELEMENT_TYPE
|
|
) {
|
|
var erroredComponent = {
|
|
name: getComponentNameFromType(blockedValue.type) || "",
|
|
owner: blockedValue._owner
|
|
};
|
|
erroredComponent.debugStack = blockedValue._debugStack;
|
|
supportsCreateTask &&
|
|
(erroredComponent.debugTask = blockedValue._debugTask);
|
|
handler._debugInfo.push(erroredComponent);
|
|
}
|
|
triggerErrorOnChunk(response, handler, error);
|
|
}
|
|
}
|
|
}
|
|
function waitForReference(
|
|
referencedChunk,
|
|
parentObject,
|
|
key,
|
|
response,
|
|
map,
|
|
path,
|
|
isAwaitingDebugInfo
|
|
) {
|
|
if (
|
|
!(
|
|
(void 0 !== response._debugChannel &&
|
|
response._debugChannel.hasReadable) ||
|
|
"pending" !== referencedChunk.status ||
|
|
parentObject[0] !== REACT_ELEMENT_TYPE ||
|
|
("4" !== key && "5" !== key)
|
|
)
|
|
)
|
|
return null;
|
|
initializingHandler
|
|
? ((response = initializingHandler), response.deps++)
|
|
: (response = initializingHandler =
|
|
{
|
|
parent: null,
|
|
chunk: null,
|
|
value: null,
|
|
reason: null,
|
|
deps: 1,
|
|
errored: !1
|
|
});
|
|
parentObject = {
|
|
handler: response,
|
|
parentObject: parentObject,
|
|
key: key,
|
|
map: map,
|
|
path: path
|
|
};
|
|
parentObject.isDebug = isAwaitingDebugInfo;
|
|
null === referencedChunk.value
|
|
? (referencedChunk.value = [parentObject])
|
|
: referencedChunk.value.push(parentObject);
|
|
null === referencedChunk.reason
|
|
? (referencedChunk.reason = [parentObject])
|
|
: referencedChunk.reason.push(parentObject);
|
|
return null;
|
|
}
|
|
function loadServerReference(response, metaData, parentObject, key) {
|
|
if (!response._serverReferenceConfig)
|
|
return createBoundServerReference(
|
|
metaData,
|
|
response._callServer,
|
|
response._encodeFormAction,
|
|
response._debugFindSourceMapURL
|
|
);
|
|
var serverReference = resolveServerReference(
|
|
response._serverReferenceConfig,
|
|
metaData.id
|
|
),
|
|
promise = preloadModule(serverReference);
|
|
if (promise)
|
|
metaData.bound && (promise = Promise.all([promise, metaData.bound]));
|
|
else if (metaData.bound) promise = Promise.resolve(metaData.bound);
|
|
else
|
|
return (
|
|
(promise = requireModule(serverReference)),
|
|
registerBoundServerReference(promise, metaData.id, metaData.bound),
|
|
promise
|
|
);
|
|
if (initializingHandler) {
|
|
var handler = initializingHandler;
|
|
handler.deps++;
|
|
} else
|
|
handler = initializingHandler = {
|
|
parent: null,
|
|
chunk: null,
|
|
value: null,
|
|
reason: null,
|
|
deps: 1,
|
|
errored: !1
|
|
};
|
|
promise.then(
|
|
function () {
|
|
var resolvedValue = requireModule(serverReference);
|
|
if (metaData.bound) {
|
|
var boundArgs = metaData.bound.value.slice(0);
|
|
boundArgs.unshift(null);
|
|
resolvedValue = resolvedValue.bind.apply(resolvedValue, boundArgs);
|
|
}
|
|
registerBoundServerReference(
|
|
resolvedValue,
|
|
metaData.id,
|
|
metaData.bound
|
|
);
|
|
"__proto__" !== key && (parentObject[key] = resolvedValue);
|
|
"" === key &&
|
|
null === handler.value &&
|
|
(handler.value = resolvedValue);
|
|
if (
|
|
parentObject[0] === REACT_ELEMENT_TYPE &&
|
|
"object" === typeof handler.value &&
|
|
null !== handler.value &&
|
|
handler.value.$$typeof === REACT_ELEMENT_TYPE
|
|
)
|
|
switch (((boundArgs = handler.value), key)) {
|
|
case "3":
|
|
boundArgs.props = resolvedValue;
|
|
break;
|
|
case "4":
|
|
boundArgs._owner = resolvedValue;
|
|
}
|
|
handler.deps--;
|
|
0 === handler.deps &&
|
|
((resolvedValue = handler.chunk),
|
|
null !== resolvedValue &&
|
|
"blocked" === resolvedValue.status &&
|
|
((boundArgs = resolvedValue.value),
|
|
(resolvedValue.status = "fulfilled"),
|
|
(resolvedValue.value = handler.value),
|
|
(resolvedValue.reason = null),
|
|
null !== boundArgs
|
|
? wakeChunk(response, boundArgs, handler.value, resolvedValue)
|
|
: ((boundArgs = handler.value),
|
|
filterDebugInfo(response, resolvedValue),
|
|
moveDebugInfoFromChunkToInnerValue(
|
|
resolvedValue,
|
|
boundArgs
|
|
))));
|
|
},
|
|
function (error) {
|
|
if (!handler.errored) {
|
|
var blockedValue = handler.value;
|
|
handler.errored = !0;
|
|
handler.value = null;
|
|
handler.reason = error;
|
|
var chunk = handler.chunk;
|
|
if (null !== chunk && "blocked" === chunk.status) {
|
|
if (
|
|
"object" === typeof blockedValue &&
|
|
null !== blockedValue &&
|
|
blockedValue.$$typeof === REACT_ELEMENT_TYPE
|
|
) {
|
|
var erroredComponent = {
|
|
name: getComponentNameFromType(blockedValue.type) || "",
|
|
owner: blockedValue._owner
|
|
};
|
|
erroredComponent.debugStack = blockedValue._debugStack;
|
|
supportsCreateTask &&
|
|
(erroredComponent.debugTask = blockedValue._debugTask);
|
|
chunk._debugInfo.push(erroredComponent);
|
|
}
|
|
triggerErrorOnChunk(response, chunk, error);
|
|
}
|
|
}
|
|
}
|
|
);
|
|
return null;
|
|
}
|
|
function resolveLazy(value) {
|
|
for (
|
|
;
|
|
"object" === typeof value &&
|
|
null !== value &&
|
|
value.$$typeof === REACT_LAZY_TYPE;
|
|
|
|
) {
|
|
var payload = value._payload;
|
|
if ("fulfilled" === payload.status) value = payload.value;
|
|
else break;
|
|
}
|
|
return value;
|
|
}
|
|
function transferReferencedDebugInfo(parentChunk, referencedChunk) {
|
|
if (null !== parentChunk) {
|
|
referencedChunk = referencedChunk._debugInfo;
|
|
parentChunk = parentChunk._debugInfo;
|
|
for (var i = 0; i < referencedChunk.length; ++i) {
|
|
var debugInfoEntry = referencedChunk[i];
|
|
null == debugInfoEntry.name && parentChunk.push(debugInfoEntry);
|
|
}
|
|
}
|
|
}
|
|
function getOutlinedModel(response, reference, parentObject, key, map) {
|
|
var path = reference.split(":");
|
|
reference = parseInt(path[0], 16);
|
|
reference = getChunk(response, reference);
|
|
null !== initializingChunk &&
|
|
isArrayImpl(initializingChunk._children) &&
|
|
initializingChunk._children.push(reference);
|
|
switch (reference.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(reference);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(reference);
|
|
}
|
|
switch (reference.status) {
|
|
case "fulfilled":
|
|
for (var value = reference.value, i = 1; i < path.length; i++) {
|
|
for (
|
|
;
|
|
"object" === typeof value &&
|
|
null !== value &&
|
|
value.$$typeof === REACT_LAZY_TYPE;
|
|
|
|
) {
|
|
value = value._payload;
|
|
switch (value.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(value);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(value);
|
|
}
|
|
switch (value.status) {
|
|
case "fulfilled":
|
|
value = value.value;
|
|
break;
|
|
case "blocked":
|
|
case "pending":
|
|
return waitForReference(
|
|
value,
|
|
parentObject,
|
|
key,
|
|
response,
|
|
map,
|
|
path.slice(i - 1),
|
|
!1
|
|
);
|
|
case "halted":
|
|
return (
|
|
initializingHandler
|
|
? ((parentObject = initializingHandler),
|
|
parentObject.deps++)
|
|
: (initializingHandler = {
|
|
parent: null,
|
|
chunk: null,
|
|
value: null,
|
|
reason: null,
|
|
deps: 1,
|
|
errored: !1
|
|
}),
|
|
null
|
|
);
|
|
default:
|
|
return (
|
|
initializingHandler
|
|
? ((initializingHandler.errored = !0),
|
|
(initializingHandler.value = null),
|
|
(initializingHandler.reason = value.reason))
|
|
: (initializingHandler = {
|
|
parent: null,
|
|
chunk: null,
|
|
value: null,
|
|
reason: value.reason,
|
|
deps: 0,
|
|
errored: !0
|
|
}),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
value = value[path[i]];
|
|
}
|
|
for (
|
|
;
|
|
"object" === typeof value &&
|
|
null !== value &&
|
|
value.$$typeof === REACT_LAZY_TYPE;
|
|
|
|
) {
|
|
path = value._payload;
|
|
switch (path.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(path);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(path);
|
|
}
|
|
switch (path.status) {
|
|
case "fulfilled":
|
|
value = path.value;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
response = map(response, value, parentObject, key);
|
|
(parentObject[0] !== REACT_ELEMENT_TYPE ||
|
|
("4" !== key && "5" !== key)) &&
|
|
transferReferencedDebugInfo(initializingChunk, reference);
|
|
return response;
|
|
case "pending":
|
|
case "blocked":
|
|
return waitForReference(
|
|
reference,
|
|
parentObject,
|
|
key,
|
|
response,
|
|
map,
|
|
path,
|
|
!1
|
|
);
|
|
case "halted":
|
|
return (
|
|
initializingHandler
|
|
? ((parentObject = initializingHandler), parentObject.deps++)
|
|
: (initializingHandler = {
|
|
parent: null,
|
|
chunk: null,
|
|
value: null,
|
|
reason: null,
|
|
deps: 1,
|
|
errored: !1
|
|
}),
|
|
null
|
|
);
|
|
default:
|
|
return (
|
|
initializingHandler
|
|
? ((initializingHandler.errored = !0),
|
|
(initializingHandler.value = null),
|
|
(initializingHandler.reason = reference.reason))
|
|
: (initializingHandler = {
|
|
parent: null,
|
|
chunk: null,
|
|
value: null,
|
|
reason: reference.reason,
|
|
deps: 0,
|
|
errored: !0
|
|
}),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
function createMap(response, model) {
|
|
return new Map(model);
|
|
}
|
|
function createSet(response, model) {
|
|
return new Set(model);
|
|
}
|
|
function createBlob(response, model) {
|
|
return new Blob(model.slice(1), { type: model[0] });
|
|
}
|
|
function createFormData(response, model) {
|
|
response = new FormData();
|
|
for (var i = 0; i < model.length; i++)
|
|
response.append(model[i][0], model[i][1]);
|
|
return response;
|
|
}
|
|
function applyConstructor(response, model, parentObject) {
|
|
Object.setPrototypeOf(parentObject, model.prototype);
|
|
}
|
|
function defineLazyGetter(response, chunk, parentObject, key) {
|
|
"__proto__" !== key &&
|
|
Object.defineProperty(parentObject, key, {
|
|
get: function () {
|
|
"resolved_model" === chunk.status && initializeModelChunk(chunk);
|
|
switch (chunk.status) {
|
|
case "fulfilled":
|
|
return chunk.value;
|
|
case "rejected":
|
|
throw chunk.reason;
|
|
}
|
|
return "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects.";
|
|
},
|
|
enumerable: !0,
|
|
configurable: !1
|
|
});
|
|
return null;
|
|
}
|
|
function extractIterator(response, model) {
|
|
return model[Symbol.iterator]();
|
|
}
|
|
function createModel(response, model) {
|
|
return model;
|
|
}
|
|
function getInferredFunctionApproximate(code) {
|
|
code = code.startsWith("Object.defineProperty(")
|
|
? code.slice(22)
|
|
: code.startsWith("(")
|
|
? code.slice(1)
|
|
: code;
|
|
if (code.startsWith("async function")) {
|
|
var idx = code.indexOf("(", 14);
|
|
if (-1 !== idx)
|
|
return (
|
|
(code = code.slice(14, idx).trim()),
|
|
(0, eval)("({" + JSON.stringify(code) + ":async function(){}})")[
|
|
code
|
|
]
|
|
);
|
|
} else if (code.startsWith("function")) {
|
|
if (((idx = code.indexOf("(", 8)), -1 !== idx))
|
|
return (
|
|
(code = code.slice(8, idx).trim()),
|
|
(0, eval)("({" + JSON.stringify(code) + ":function(){}})")[code]
|
|
);
|
|
} else if (
|
|
code.startsWith("class") &&
|
|
((idx = code.indexOf("{", 5)), -1 !== idx)
|
|
)
|
|
return (
|
|
(code = code.slice(5, idx).trim()),
|
|
(0, eval)("({" + JSON.stringify(code) + ":class{}})")[code]
|
|
);
|
|
return function () {};
|
|
}
|
|
function parseModelString(response, parentObject, key, value) {
|
|
if ("$" === value[0]) {
|
|
if ("$" === value)
|
|
return (
|
|
null !== initializingHandler &&
|
|
"0" === key &&
|
|
(initializingHandler = {
|
|
parent: initializingHandler,
|
|
chunk: null,
|
|
value: null,
|
|
reason: null,
|
|
deps: 0,
|
|
errored: !1
|
|
}),
|
|
REACT_ELEMENT_TYPE
|
|
);
|
|
switch (value[1]) {
|
|
case "$":
|
|
return value.slice(1);
|
|
case "L":
|
|
return (
|
|
(parentObject = parseInt(value.slice(2), 16)),
|
|
(response = getChunk(response, parentObject)),
|
|
null !== initializingChunk &&
|
|
isArrayImpl(initializingChunk._children) &&
|
|
initializingChunk._children.push(response),
|
|
createLazyChunkWrapper(response, 0)
|
|
);
|
|
case "@":
|
|
return (
|
|
(parentObject = parseInt(value.slice(2), 16)),
|
|
(response = getChunk(response, parentObject)),
|
|
null !== initializingChunk &&
|
|
isArrayImpl(initializingChunk._children) &&
|
|
initializingChunk._children.push(response),
|
|
response
|
|
);
|
|
case "S":
|
|
return Symbol.for(value.slice(2));
|
|
case "h":
|
|
var ref = value.slice(2);
|
|
return getOutlinedModel(
|
|
response,
|
|
ref,
|
|
parentObject,
|
|
key,
|
|
loadServerReference
|
|
);
|
|
case "T":
|
|
parentObject = "$" + value.slice(2);
|
|
response = response._tempRefs;
|
|
if (null == response)
|
|
throw Error(
|
|
"Missing a temporary reference set but the RSC response returned a temporary reference. Pass a temporaryReference option with the set that was used with the reply."
|
|
);
|
|
return response.get(parentObject);
|
|
case "Q":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(response, ref, parentObject, key, createMap)
|
|
);
|
|
case "W":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(response, ref, parentObject, key, createSet)
|
|
);
|
|
case "B":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(response, ref, parentObject, key, createBlob)
|
|
);
|
|
case "K":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(response, ref, parentObject, key, createFormData)
|
|
);
|
|
case "Z":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(
|
|
response,
|
|
ref,
|
|
parentObject,
|
|
key,
|
|
resolveErrorDev
|
|
)
|
|
);
|
|
case "i":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(
|
|
response,
|
|
ref,
|
|
parentObject,
|
|
key,
|
|
extractIterator
|
|
)
|
|
);
|
|
case "I":
|
|
return Infinity;
|
|
case "-":
|
|
return "$-0" === value ? -0 : -Infinity;
|
|
case "N":
|
|
return NaN;
|
|
case "u":
|
|
return;
|
|
case "D":
|
|
return new Date(Date.parse(value.slice(2)));
|
|
case "n":
|
|
return BigInt(value.slice(2));
|
|
case "P":
|
|
return (
|
|
(ref = value.slice(2)),
|
|
getOutlinedModel(
|
|
response,
|
|
ref,
|
|
parentObject,
|
|
key,
|
|
applyConstructor
|
|
)
|
|
);
|
|
case "E":
|
|
response = value.slice(2);
|
|
try {
|
|
if (!mightHaveStaticConstructor.test(response))
|
|
return (0, eval)(response);
|
|
} catch (x) {}
|
|
try {
|
|
if (
|
|
((ref = getInferredFunctionApproximate(response)),
|
|
response.startsWith("Object.defineProperty("))
|
|
) {
|
|
var idx = response.lastIndexOf(',"name",{value:"');
|
|
if (-1 !== idx) {
|
|
var name = JSON.parse(
|
|
response.slice(idx + 16 - 1, response.length - 2)
|
|
);
|
|
Object.defineProperty(ref, "name", { value: name });
|
|
}
|
|
}
|
|
} catch (_) {
|
|
ref = function () {};
|
|
}
|
|
return ref;
|
|
case "Y":
|
|
if (
|
|
2 < value.length &&
|
|
(ref = response._debugChannel && response._debugChannel.callback)
|
|
) {
|
|
if ("@" === value[2])
|
|
return (
|
|
(parentObject = value.slice(3)),
|
|
(key = parseInt(parentObject, 16)),
|
|
response._chunks.has(key) || ref("P:" + parentObject),
|
|
getChunk(response, key)
|
|
);
|
|
value = value.slice(2);
|
|
idx = parseInt(value, 16);
|
|
response._chunks.has(idx) || ref("Q:" + value);
|
|
ref = getChunk(response, idx);
|
|
return "fulfilled" === ref.status
|
|
? ref.value
|
|
: defineLazyGetter(response, ref, parentObject, key);
|
|
}
|
|
"__proto__" !== key &&
|
|
Object.defineProperty(parentObject, key, {
|
|
get: function () {
|
|
return "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects.";
|
|
},
|
|
enumerable: !0,
|
|
configurable: !1
|
|
});
|
|
return null;
|
|
default:
|
|
return (
|
|
(ref = value.slice(1)),
|
|
getOutlinedModel(response, ref, parentObject, key, createModel)
|
|
);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function missingCall() {
|
|
throw Error(
|
|
'Trying to call a function from "use server" but the callServer option was not implemented in your router runtime.'
|
|
);
|
|
}
|
|
function markIOStarted() {
|
|
this._debugIOStarted = !0;
|
|
}
|
|
function ResponseInstance(
|
|
bundlerConfig,
|
|
serverReferenceConfig,
|
|
moduleLoading,
|
|
callServer,
|
|
encodeFormAction,
|
|
nonce,
|
|
temporaryReferences,
|
|
findSourceMapURL,
|
|
replayConsole,
|
|
environmentName,
|
|
debugStartTime,
|
|
debugEndTime,
|
|
debugChannel
|
|
) {
|
|
var chunks = new Map();
|
|
this._bundlerConfig = bundlerConfig;
|
|
this._serverReferenceConfig = serverReferenceConfig;
|
|
this._moduleLoading = moduleLoading;
|
|
this._callServer = void 0 !== callServer ? callServer : missingCall;
|
|
this._encodeFormAction = encodeFormAction;
|
|
this._nonce = nonce;
|
|
this._chunks = chunks;
|
|
this._stringDecoder = new TextDecoder();
|
|
this._fromJSON = null;
|
|
this._closed = !1;
|
|
this._closedReason = null;
|
|
this._tempRefs = temporaryReferences;
|
|
this._timeOrigin = 0;
|
|
this._pendingInitialRender = null;
|
|
this._pendingChunks = 0;
|
|
this._weakResponse = { weak: new WeakRef(this), response: this };
|
|
this._debugRootOwner = bundlerConfig =
|
|
void 0 === ReactSharedInteralsServer ||
|
|
null === ReactSharedInteralsServer.A
|
|
? null
|
|
: ReactSharedInteralsServer.A.getOwner();
|
|
this._debugRootStack =
|
|
null !== bundlerConfig ? Error("react-stack-top-frame") : null;
|
|
environmentName = void 0 === environmentName ? "Server" : environmentName;
|
|
supportsCreateTask &&
|
|
(this._debugRootTask = console.createTask(
|
|
'"use ' + environmentName.toLowerCase() + '"'
|
|
));
|
|
this._debugStartTime =
|
|
null == debugStartTime ? performance.now() : debugStartTime;
|
|
this._debugIOStarted = !1;
|
|
setTimeout(markIOStarted.bind(this), 0);
|
|
this._debugEndTime = null == debugEndTime ? null : debugEndTime;
|
|
this._debugFindSourceMapURL = findSourceMapURL;
|
|
this._debugChannel = debugChannel;
|
|
this._blockedConsole = null;
|
|
this._replayConsole = replayConsole;
|
|
this._rootEnvironmentName = environmentName;
|
|
debugChannel &&
|
|
(null === debugChannelRegistry
|
|
? (closeDebugChannel(debugChannel), (this._debugChannel = void 0))
|
|
: debugChannelRegistry.register(this, debugChannel, this));
|
|
replayConsole && markAllTracksInOrder();
|
|
this._fromJSON = createFromJSONCallback(this);
|
|
}
|
|
function createStreamState(weakResponse, streamDebugValue) {
|
|
var streamState = {
|
|
_rowState: 0,
|
|
_rowID: 0,
|
|
_rowTag: 0,
|
|
_rowLength: 0,
|
|
_buffer: []
|
|
};
|
|
weakResponse = unwrapWeakResponse(weakResponse);
|
|
var debugValuePromise = Promise.resolve(streamDebugValue);
|
|
debugValuePromise.status = "fulfilled";
|
|
debugValuePromise.value = streamDebugValue;
|
|
streamState._debugInfo = {
|
|
name: "rsc stream",
|
|
start: weakResponse._debugStartTime,
|
|
end: weakResponse._debugStartTime,
|
|
byteSize: 0,
|
|
value: debugValuePromise,
|
|
owner: weakResponse._debugRootOwner,
|
|
debugStack: weakResponse._debugRootStack,
|
|
debugTask: weakResponse._debugRootTask
|
|
};
|
|
streamState._debugTargetChunkSize = MIN_CHUNK_SIZE;
|
|
return streamState;
|
|
}
|
|
function incrementChunkDebugInfo(streamState, chunkLength) {
|
|
var debugInfo = streamState._debugInfo,
|
|
endTime = performance.now(),
|
|
previousEndTime = debugInfo.end;
|
|
chunkLength = debugInfo.byteSize + chunkLength;
|
|
chunkLength > streamState._debugTargetChunkSize ||
|
|
endTime > previousEndTime + 10
|
|
? ((streamState._debugInfo = {
|
|
name: debugInfo.name,
|
|
start: debugInfo.start,
|
|
end: endTime,
|
|
byteSize: chunkLength,
|
|
value: debugInfo.value,
|
|
owner: debugInfo.owner,
|
|
debugStack: debugInfo.debugStack,
|
|
debugTask: debugInfo.debugTask
|
|
}),
|
|
(streamState._debugTargetChunkSize = chunkLength + MIN_CHUNK_SIZE))
|
|
: ((debugInfo.end = endTime), (debugInfo.byteSize = chunkLength));
|
|
}
|
|
function addAsyncInfo(chunk, asyncInfo) {
|
|
var value = resolveLazy(chunk.value);
|
|
"object" !== typeof value ||
|
|
null === value ||
|
|
(!isArrayImpl(value) &&
|
|
"function" !== typeof value[ASYNC_ITERATOR] &&
|
|
value.$$typeof !== REACT_ELEMENT_TYPE &&
|
|
value.$$typeof !== REACT_LAZY_TYPE)
|
|
? chunk._debugInfo.push(asyncInfo)
|
|
: isArrayImpl(value._debugInfo)
|
|
? value._debugInfo.push(asyncInfo)
|
|
: Object.defineProperty(value, "_debugInfo", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: [asyncInfo]
|
|
});
|
|
}
|
|
function resolveChunkDebugInfo(response, streamState, chunk) {
|
|
response._debugIOStarted &&
|
|
((response = { awaited: streamState._debugInfo }),
|
|
"pending" === chunk.status || "blocked" === chunk.status
|
|
? ((response = addAsyncInfo.bind(null, chunk, response)),
|
|
chunk.then(response, response))
|
|
: addAsyncInfo(chunk, response));
|
|
}
|
|
function resolveBuffer(response, id, buffer, streamState) {
|
|
var chunks = response._chunks,
|
|
chunk = chunks.get(id);
|
|
chunk && "pending" !== chunk.status
|
|
? chunk.reason.enqueueValue(buffer)
|
|
: (chunk && releasePendingChunk(response, chunk),
|
|
(buffer = new ReactPromise("fulfilled", buffer, null)),
|
|
resolveChunkDebugInfo(response, streamState, buffer),
|
|
chunks.set(id, buffer));
|
|
}
|
|
function resolveModule(response, id, model, streamState) {
|
|
var chunks = response._chunks,
|
|
chunk = chunks.get(id);
|
|
model = JSON.parse(model, response._fromJSON);
|
|
var clientReference = resolveClientReference(
|
|
response._bundlerConfig,
|
|
model
|
|
);
|
|
if ((model = preloadModule(clientReference))) {
|
|
if (chunk) {
|
|
releasePendingChunk(response, chunk);
|
|
var blockedChunk = chunk;
|
|
blockedChunk.status = "blocked";
|
|
} else
|
|
(blockedChunk = new ReactPromise("blocked", null, null)),
|
|
chunks.set(id, blockedChunk);
|
|
resolveChunkDebugInfo(response, streamState, blockedChunk);
|
|
model.then(
|
|
function () {
|
|
return resolveModuleChunk(response, blockedChunk, clientReference);
|
|
},
|
|
function (error) {
|
|
return triggerErrorOnChunk(response, blockedChunk, error);
|
|
}
|
|
);
|
|
} else
|
|
chunk
|
|
? (resolveChunkDebugInfo(response, streamState, chunk),
|
|
resolveModuleChunk(response, chunk, clientReference))
|
|
: ((chunk = new ReactPromise(
|
|
"resolved_module",
|
|
clientReference,
|
|
null
|
|
)),
|
|
resolveChunkDebugInfo(response, streamState, chunk),
|
|
chunks.set(id, chunk));
|
|
}
|
|
function resolveStream(response, id, stream, controller, streamState) {
|
|
var chunks = response._chunks,
|
|
chunk = chunks.get(id);
|
|
if (chunk) {
|
|
if (
|
|
(resolveChunkDebugInfo(response, streamState, chunk),
|
|
"pending" === chunk.status)
|
|
) {
|
|
id = chunk.value;
|
|
if (null != chunk._debugChunk) {
|
|
streamState = initializingHandler;
|
|
chunks = initializingChunk;
|
|
initializingHandler = null;
|
|
chunk.status = "blocked";
|
|
chunk.value = null;
|
|
chunk.reason = null;
|
|
initializingChunk = chunk;
|
|
try {
|
|
if (
|
|
(initializeDebugChunk(response, chunk),
|
|
null !== initializingHandler &&
|
|
!initializingHandler.errored &&
|
|
0 < initializingHandler.deps)
|
|
) {
|
|
initializingHandler.value = stream;
|
|
initializingHandler.reason = controller;
|
|
initializingHandler.chunk = chunk;
|
|
return;
|
|
}
|
|
} finally {
|
|
(initializingHandler = streamState), (initializingChunk = chunks);
|
|
}
|
|
}
|
|
chunk.status = "fulfilled";
|
|
chunk.value = stream;
|
|
chunk.reason = controller;
|
|
null !== id
|
|
? wakeChunk(response, id, chunk.value, chunk)
|
|
: (filterDebugInfo(response, chunk),
|
|
moveDebugInfoFromChunkToInnerValue(chunk, stream));
|
|
}
|
|
} else
|
|
0 === response._pendingChunks++ &&
|
|
(response._weakResponse.response = response),
|
|
(stream = new ReactPromise("fulfilled", stream, controller)),
|
|
resolveChunkDebugInfo(response, streamState, stream),
|
|
chunks.set(id, stream);
|
|
}
|
|
function startReadableStream(response, id, type, streamState) {
|
|
var controller = null,
|
|
closed = !1;
|
|
type = new ReadableStream({
|
|
type: type,
|
|
start: function (c) {
|
|
controller = c;
|
|
}
|
|
});
|
|
var previousBlockedChunk = null;
|
|
resolveStream(
|
|
response,
|
|
id,
|
|
type,
|
|
{
|
|
enqueueValue: function (value) {
|
|
null === previousBlockedChunk
|
|
? controller.enqueue(value)
|
|
: previousBlockedChunk.then(function () {
|
|
controller.enqueue(value);
|
|
});
|
|
},
|
|
enqueueModel: function (json) {
|
|
if (null === previousBlockedChunk) {
|
|
var chunk = createResolvedModelChunk(response, json);
|
|
initializeModelChunk(chunk);
|
|
"fulfilled" === chunk.status
|
|
? controller.enqueue(chunk.value)
|
|
: (chunk.then(
|
|
function (v) {
|
|
return controller.enqueue(v);
|
|
},
|
|
function (e) {
|
|
return controller.error(e);
|
|
}
|
|
),
|
|
(previousBlockedChunk = chunk));
|
|
} else {
|
|
chunk = previousBlockedChunk;
|
|
var _chunk3 = createPendingChunk(response);
|
|
_chunk3.then(
|
|
function (v) {
|
|
return controller.enqueue(v);
|
|
},
|
|
function (e) {
|
|
return controller.error(e);
|
|
}
|
|
);
|
|
previousBlockedChunk = _chunk3;
|
|
chunk.then(function () {
|
|
previousBlockedChunk === _chunk3 &&
|
|
(previousBlockedChunk = null);
|
|
resolveModelChunk(response, _chunk3, json);
|
|
});
|
|
}
|
|
},
|
|
close: function () {
|
|
if (!closed)
|
|
if (((closed = !0), null === previousBlockedChunk))
|
|
controller.close();
|
|
else {
|
|
var blockedChunk = previousBlockedChunk;
|
|
previousBlockedChunk = null;
|
|
blockedChunk.then(function () {
|
|
return controller.close();
|
|
});
|
|
}
|
|
},
|
|
error: function (error) {
|
|
if (!closed)
|
|
if (((closed = !0), null === previousBlockedChunk))
|
|
controller.error(error);
|
|
else {
|
|
var blockedChunk = previousBlockedChunk;
|
|
previousBlockedChunk = null;
|
|
blockedChunk.then(function () {
|
|
return controller.error(error);
|
|
});
|
|
}
|
|
}
|
|
},
|
|
streamState
|
|
);
|
|
}
|
|
function asyncIterator() {
|
|
return this;
|
|
}
|
|
function createIterator(next) {
|
|
next = { next: next };
|
|
next[ASYNC_ITERATOR] = asyncIterator;
|
|
return next;
|
|
}
|
|
function startAsyncIterable(response, id, iterator, streamState) {
|
|
var buffer = [],
|
|
closed = !1,
|
|
nextWriteIndex = 0,
|
|
iterable = {};
|
|
iterable[ASYNC_ITERATOR] = function () {
|
|
var nextReadIndex = 0;
|
|
return createIterator(function (arg) {
|
|
if (void 0 !== arg)
|
|
throw Error(
|
|
"Values cannot be passed to next() of AsyncIterables passed to Client Components."
|
|
);
|
|
if (nextReadIndex === buffer.length) {
|
|
if (closed)
|
|
return new ReactPromise(
|
|
"fulfilled",
|
|
{ done: !0, value: void 0 },
|
|
null
|
|
);
|
|
buffer[nextReadIndex] = createPendingChunk(response);
|
|
}
|
|
return buffer[nextReadIndex++];
|
|
});
|
|
};
|
|
resolveStream(
|
|
response,
|
|
id,
|
|
iterator ? iterable[ASYNC_ITERATOR]() : iterable,
|
|
{
|
|
enqueueValue: function (value) {
|
|
if (nextWriteIndex === buffer.length)
|
|
buffer[nextWriteIndex] = new ReactPromise(
|
|
"fulfilled",
|
|
{ done: !1, value: value },
|
|
null
|
|
);
|
|
else {
|
|
var chunk = buffer[nextWriteIndex],
|
|
resolveListeners = chunk.value,
|
|
rejectListeners = chunk.reason;
|
|
chunk.status = "fulfilled";
|
|
chunk.value = { done: !1, value: value };
|
|
chunk.reason = null;
|
|
null !== resolveListeners &&
|
|
wakeChunkIfInitialized(
|
|
response,
|
|
chunk,
|
|
resolveListeners,
|
|
rejectListeners
|
|
);
|
|
}
|
|
nextWriteIndex++;
|
|
},
|
|
enqueueModel: function (value) {
|
|
nextWriteIndex === buffer.length
|
|
? (buffer[nextWriteIndex] = createResolvedIteratorResultChunk(
|
|
response,
|
|
value,
|
|
!1
|
|
))
|
|
: resolveIteratorResultChunk(
|
|
response,
|
|
buffer[nextWriteIndex],
|
|
value,
|
|
!1
|
|
);
|
|
nextWriteIndex++;
|
|
},
|
|
close: function (value) {
|
|
if (!closed)
|
|
for (
|
|
closed = !0,
|
|
nextWriteIndex === buffer.length
|
|
? (buffer[nextWriteIndex] =
|
|
createResolvedIteratorResultChunk(response, value, !0))
|
|
: resolveIteratorResultChunk(
|
|
response,
|
|
buffer[nextWriteIndex],
|
|
value,
|
|
!0
|
|
),
|
|
nextWriteIndex++;
|
|
nextWriteIndex < buffer.length;
|
|
|
|
)
|
|
resolveIteratorResultChunk(
|
|
response,
|
|
buffer[nextWriteIndex++],
|
|
'"$undefined"',
|
|
!0
|
|
);
|
|
},
|
|
error: function (error) {
|
|
if (!closed)
|
|
for (
|
|
closed = !0,
|
|
nextWriteIndex === buffer.length &&
|
|
(buffer[nextWriteIndex] = createPendingChunk(response));
|
|
nextWriteIndex < buffer.length;
|
|
|
|
)
|
|
triggerErrorOnChunk(response, buffer[nextWriteIndex++], error);
|
|
}
|
|
},
|
|
streamState
|
|
);
|
|
}
|
|
function resolveErrorDev(response, errorInfo) {
|
|
var name = errorInfo.name,
|
|
env = errorInfo.env;
|
|
var error = buildFakeCallStack(
|
|
response,
|
|
errorInfo.stack,
|
|
env,
|
|
!1,
|
|
Error.bind(
|
|
null,
|
|
errorInfo.message ||
|
|
"An error occurred in the Server Components render but no message was provided"
|
|
)
|
|
);
|
|
var ownerTask = null;
|
|
null != errorInfo.owner &&
|
|
((errorInfo = errorInfo.owner.slice(1)),
|
|
(errorInfo = getOutlinedModel(
|
|
response,
|
|
errorInfo,
|
|
{},
|
|
"",
|
|
createModel
|
|
)),
|
|
null !== errorInfo &&
|
|
(ownerTask = initializeFakeTask(response, errorInfo)));
|
|
null === ownerTask
|
|
? ((response = getRootTask(response, env)),
|
|
(error = null != response ? response.run(error) : error()))
|
|
: (error = ownerTask.run(error));
|
|
error.name = name;
|
|
error.environmentName = env;
|
|
return error;
|
|
}
|
|
function createFakeFunction(
|
|
name,
|
|
filename,
|
|
sourceMap,
|
|
line,
|
|
col,
|
|
enclosingLine,
|
|
enclosingCol,
|
|
environmentName
|
|
) {
|
|
name || (name = "<anonymous>");
|
|
var encodedName = JSON.stringify(name);
|
|
1 > enclosingLine ? (enclosingLine = 0) : enclosingLine--;
|
|
1 > enclosingCol ? (enclosingCol = 0) : enclosingCol--;
|
|
1 > line ? (line = 0) : line--;
|
|
1 > col ? (col = 0) : col--;
|
|
if (
|
|
line < enclosingLine ||
|
|
(line === enclosingLine && col < enclosingCol)
|
|
)
|
|
enclosingCol = enclosingLine = 0;
|
|
1 > line
|
|
? ((line = encodedName.length + 3),
|
|
(enclosingCol -= line),
|
|
0 > enclosingCol && (enclosingCol = 0),
|
|
(col = col - enclosingCol - line - 3),
|
|
0 > col && (col = 0),
|
|
(encodedName =
|
|
"({" +
|
|
encodedName +
|
|
":" +
|
|
" ".repeat(enclosingCol) +
|
|
"_=>" +
|
|
" ".repeat(col) +
|
|
"_()})"))
|
|
: 1 > enclosingLine
|
|
? ((enclosingCol -= encodedName.length + 3),
|
|
0 > enclosingCol && (enclosingCol = 0),
|
|
(encodedName =
|
|
"({" +
|
|
encodedName +
|
|
":" +
|
|
" ".repeat(enclosingCol) +
|
|
"_=>" +
|
|
"\n".repeat(line - enclosingLine) +
|
|
" ".repeat(col) +
|
|
"_()})"))
|
|
: enclosingLine === line
|
|
? ((col = col - enclosingCol - 3),
|
|
0 > col && (col = 0),
|
|
(encodedName =
|
|
"\n".repeat(enclosingLine - 1) +
|
|
"({" +
|
|
encodedName +
|
|
":\n" +
|
|
" ".repeat(enclosingCol) +
|
|
"_=>" +
|
|
" ".repeat(col) +
|
|
"_()})"))
|
|
: (encodedName =
|
|
"\n".repeat(enclosingLine - 1) +
|
|
"({" +
|
|
encodedName +
|
|
":\n" +
|
|
" ".repeat(enclosingCol) +
|
|
"_=>" +
|
|
"\n".repeat(line - enclosingLine) +
|
|
" ".repeat(col) +
|
|
"_()})");
|
|
encodedName =
|
|
1 > enclosingLine
|
|
? encodedName +
|
|
"\n/* This module was rendered by a Server Component. Turn on Source Maps to see the server source. */"
|
|
: "/* This module was rendered by a Server Component. Turn on Source Maps to see the server source. */" +
|
|
encodedName;
|
|
filename.startsWith("/") && (filename = "file://" + filename);
|
|
sourceMap
|
|
? ((encodedName +=
|
|
"\n//# sourceURL=about://React/" +
|
|
encodeURIComponent(environmentName) +
|
|
"/" +
|
|
encodeURI(filename) +
|
|
"?" +
|
|
fakeFunctionIdx++),
|
|
(encodedName += "\n//# sourceMappingURL=" + sourceMap))
|
|
: (encodedName = filename
|
|
? encodedName + ("\n//# sourceURL=" + encodeURI(filename))
|
|
: encodedName + "\n//# sourceURL=<anonymous>");
|
|
try {
|
|
var fn = (0, eval)(encodedName)[name];
|
|
} catch (x) {
|
|
fn = function (_) {
|
|
return _();
|
|
};
|
|
}
|
|
return fn;
|
|
}
|
|
function buildFakeCallStack(
|
|
response,
|
|
stack,
|
|
environmentName,
|
|
useEnclosingLine,
|
|
innerCall
|
|
) {
|
|
for (var i = 0; i < stack.length; i++) {
|
|
var frame = stack[i],
|
|
frameKey =
|
|
frame.join("-") +
|
|
"-" +
|
|
environmentName +
|
|
(useEnclosingLine ? "-e" : "-n"),
|
|
fn = fakeFunctionCache.get(frameKey);
|
|
if (void 0 === fn) {
|
|
fn = frame[0];
|
|
var filename = frame[1],
|
|
line = frame[2],
|
|
col = frame[3],
|
|
enclosingLine = frame[4];
|
|
frame = frame[5];
|
|
var findSourceMapURL = response._debugFindSourceMapURL;
|
|
findSourceMapURL = findSourceMapURL
|
|
? findSourceMapURL(filename, environmentName)
|
|
: null;
|
|
fn = createFakeFunction(
|
|
fn,
|
|
filename,
|
|
findSourceMapURL,
|
|
line,
|
|
col,
|
|
useEnclosingLine ? line : enclosingLine,
|
|
useEnclosingLine ? col : frame,
|
|
environmentName
|
|
);
|
|
fakeFunctionCache.set(frameKey, fn);
|
|
}
|
|
innerCall = fn.bind(null, innerCall);
|
|
}
|
|
return innerCall;
|
|
}
|
|
function getRootTask(response, childEnvironmentName) {
|
|
var rootTask = response._debugRootTask;
|
|
return rootTask
|
|
? response._rootEnvironmentName !== childEnvironmentName
|
|
? ((response = console.createTask.bind(
|
|
console,
|
|
'"use ' + childEnvironmentName.toLowerCase() + '"'
|
|
)),
|
|
rootTask.run(response))
|
|
: rootTask
|
|
: null;
|
|
}
|
|
function initializeFakeTask(response, debugInfo) {
|
|
if (!supportsCreateTask || null == debugInfo.stack) return null;
|
|
var cachedEntry = debugInfo.debugTask;
|
|
if (void 0 !== cachedEntry) return cachedEntry;
|
|
var useEnclosingLine = void 0 === debugInfo.key,
|
|
stack = debugInfo.stack,
|
|
env =
|
|
null == debugInfo.env ? response._rootEnvironmentName : debugInfo.env;
|
|
cachedEntry =
|
|
null == debugInfo.owner || null == debugInfo.owner.env
|
|
? response._rootEnvironmentName
|
|
: debugInfo.owner.env;
|
|
var ownerTask =
|
|
null == debugInfo.owner
|
|
? null
|
|
: initializeFakeTask(response, debugInfo.owner);
|
|
env =
|
|
env !== cachedEntry
|
|
? '"use ' + env.toLowerCase() + '"'
|
|
: void 0 !== debugInfo.key
|
|
? "<" + (debugInfo.name || "...") + ">"
|
|
: void 0 !== debugInfo.name
|
|
? debugInfo.name || "unknown"
|
|
: "await " + (debugInfo.awaited.name || "unknown");
|
|
env = console.createTask.bind(console, env);
|
|
useEnclosingLine = buildFakeCallStack(
|
|
response,
|
|
stack,
|
|
cachedEntry,
|
|
useEnclosingLine,
|
|
env
|
|
);
|
|
null === ownerTask
|
|
? ((response = getRootTask(response, cachedEntry)),
|
|
(response =
|
|
null != response
|
|
? response.run(useEnclosingLine)
|
|
: useEnclosingLine()))
|
|
: (response = ownerTask.run(useEnclosingLine));
|
|
return (debugInfo.debugTask = response);
|
|
}
|
|
function fakeJSXCallSite() {
|
|
return Error("react-stack-top-frame");
|
|
}
|
|
function initializeFakeStack(response, debugInfo) {
|
|
if (void 0 === debugInfo.debugStack) {
|
|
null != debugInfo.stack &&
|
|
(debugInfo.debugStack = createFakeJSXCallStackInDEV(
|
|
response,
|
|
debugInfo.stack,
|
|
null == debugInfo.env ? "" : debugInfo.env
|
|
));
|
|
var owner = debugInfo.owner;
|
|
null != owner &&
|
|
(initializeFakeStack(response, owner),
|
|
void 0 === owner.debugLocation &&
|
|
null != debugInfo.debugStack &&
|
|
(owner.debugLocation = debugInfo.debugStack));
|
|
}
|
|
}
|
|
function initializeDebugInfo(response, debugInfo) {
|
|
void 0 !== debugInfo.stack && initializeFakeTask(response, debugInfo);
|
|
if (null == debugInfo.owner && null != response._debugRootOwner) {
|
|
var _componentInfoOrAsyncInfo = debugInfo;
|
|
_componentInfoOrAsyncInfo.owner = response._debugRootOwner;
|
|
_componentInfoOrAsyncInfo.stack = null;
|
|
_componentInfoOrAsyncInfo.debugStack = response._debugRootStack;
|
|
_componentInfoOrAsyncInfo.debugTask = response._debugRootTask;
|
|
} else
|
|
void 0 !== debugInfo.stack && initializeFakeStack(response, debugInfo);
|
|
"number" === typeof debugInfo.time &&
|
|
(debugInfo = { time: debugInfo.time + response._timeOrigin });
|
|
return debugInfo;
|
|
}
|
|
function getCurrentStackInDEV() {
|
|
var owner = currentOwnerInDEV;
|
|
if (null === owner) return "";
|
|
try {
|
|
var info = "";
|
|
if (owner.owner || "string" !== typeof owner.name) {
|
|
for (; owner; ) {
|
|
var ownerStack = owner.debugStack;
|
|
if (null != ownerStack) {
|
|
if ((owner = owner.owner)) {
|
|
var JSCompiler_temp_const = info;
|
|
var error = ownerStack,
|
|
prevPrepareStackTrace = Error.prepareStackTrace;
|
|
Error.prepareStackTrace = void 0;
|
|
var stack = error.stack;
|
|
Error.prepareStackTrace = prevPrepareStackTrace;
|
|
stack.startsWith("Error: react-stack-top-frame\n") &&
|
|
(stack = stack.slice(29));
|
|
var idx = stack.indexOf("\n");
|
|
-1 !== idx && (stack = stack.slice(idx + 1));
|
|
idx = stack.indexOf("react_stack_bottom_frame");
|
|
-1 !== idx && (idx = stack.lastIndexOf("\n", idx));
|
|
var JSCompiler_inline_result =
|
|
-1 !== idx ? (stack = stack.slice(0, idx)) : "";
|
|
info =
|
|
JSCompiler_temp_const + ("\n" + JSCompiler_inline_result);
|
|
}
|
|
} else break;
|
|
}
|
|
var JSCompiler_inline_result$jscomp$0 = info;
|
|
} else {
|
|
JSCompiler_temp_const = owner.name;
|
|
if (void 0 === prefix)
|
|
try {
|
|
throw Error();
|
|
} catch (x) {
|
|
(prefix =
|
|
((error = x.stack.trim().match(/\n( *(at )?)/)) && error[1]) ||
|
|
""),
|
|
(suffix =
|
|
-1 < x.stack.indexOf("\n at")
|
|
? " (<anonymous>)"
|
|
: -1 < x.stack.indexOf("@")
|
|
? "@unknown:0:0"
|
|
: "");
|
|
}
|
|
JSCompiler_inline_result$jscomp$0 =
|
|
"\n" + prefix + JSCompiler_temp_const + suffix;
|
|
}
|
|
} catch (x) {
|
|
JSCompiler_inline_result$jscomp$0 =
|
|
"\nError generating stack: " + x.message + "\n" + x.stack;
|
|
}
|
|
return JSCompiler_inline_result$jscomp$0;
|
|
}
|
|
function resolveConsoleEntry(response, json) {
|
|
if (response._replayConsole) {
|
|
var blockedChunk = response._blockedConsole;
|
|
if (null == blockedChunk)
|
|
(blockedChunk = createResolvedModelChunk(response, json)),
|
|
initializeModelChunk(blockedChunk),
|
|
"fulfilled" === blockedChunk.status
|
|
? replayConsoleWithCallStackInDEV(response, blockedChunk.value)
|
|
: (blockedChunk.then(
|
|
function (v) {
|
|
return replayConsoleWithCallStackInDEV(response, v);
|
|
},
|
|
function () {}
|
|
),
|
|
(response._blockedConsole = blockedChunk));
|
|
else {
|
|
var _chunk4 = createPendingChunk(response);
|
|
_chunk4.then(
|
|
function (v) {
|
|
return replayConsoleWithCallStackInDEV(response, v);
|
|
},
|
|
function () {}
|
|
);
|
|
response._blockedConsole = _chunk4;
|
|
var unblock = function () {
|
|
response._blockedConsole === _chunk4 &&
|
|
(response._blockedConsole = null);
|
|
resolveModelChunk(response, _chunk4, json);
|
|
};
|
|
blockedChunk.then(unblock, unblock);
|
|
}
|
|
}
|
|
}
|
|
function initializeIOInfo(response, ioInfo) {
|
|
void 0 !== ioInfo.stack &&
|
|
(initializeFakeTask(response, ioInfo),
|
|
initializeFakeStack(response, ioInfo));
|
|
ioInfo.start += response._timeOrigin;
|
|
ioInfo.end += response._timeOrigin;
|
|
if (response._replayConsole) {
|
|
response = response._rootEnvironmentName;
|
|
var promise = ioInfo.value;
|
|
if (promise)
|
|
switch (promise.status) {
|
|
case "fulfilled":
|
|
logIOInfo(ioInfo, response, promise.value);
|
|
break;
|
|
case "rejected":
|
|
logIOInfoErrored(ioInfo, response, promise.reason);
|
|
break;
|
|
default:
|
|
promise.then(
|
|
logIOInfo.bind(null, ioInfo, response),
|
|
logIOInfoErrored.bind(null, ioInfo, response)
|
|
);
|
|
}
|
|
else logIOInfo(ioInfo, response, void 0);
|
|
}
|
|
}
|
|
function resolveIOInfo(response, id, model) {
|
|
var chunks = response._chunks,
|
|
chunk = chunks.get(id);
|
|
chunk
|
|
? (resolveModelChunk(response, chunk, model),
|
|
"resolved_model" === chunk.status && initializeModelChunk(chunk))
|
|
: ((chunk = createResolvedModelChunk(response, model)),
|
|
chunks.set(id, chunk),
|
|
initializeModelChunk(chunk));
|
|
"fulfilled" === chunk.status
|
|
? initializeIOInfo(response, chunk.value)
|
|
: chunk.then(
|
|
function (v) {
|
|
initializeIOInfo(response, v);
|
|
},
|
|
function () {}
|
|
);
|
|
}
|
|
function mergeBuffer(buffer, lastChunk) {
|
|
for (
|
|
var l = buffer.length, byteLength = lastChunk.length, i = 0;
|
|
i < l;
|
|
i++
|
|
)
|
|
byteLength += buffer[i].byteLength;
|
|
byteLength = new Uint8Array(byteLength);
|
|
for (var _i3 = (i = 0); _i3 < l; _i3++) {
|
|
var chunk = buffer[_i3];
|
|
byteLength.set(chunk, i);
|
|
i += chunk.byteLength;
|
|
}
|
|
byteLength.set(lastChunk, i);
|
|
return byteLength;
|
|
}
|
|
function resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
lastChunk,
|
|
constructor,
|
|
bytesPerElement,
|
|
streamState
|
|
) {
|
|
buffer =
|
|
0 === buffer.length && 0 === lastChunk.byteOffset % bytesPerElement
|
|
? lastChunk
|
|
: mergeBuffer(buffer, lastChunk);
|
|
constructor = new constructor(
|
|
buffer.buffer,
|
|
buffer.byteOffset,
|
|
buffer.byteLength / bytesPerElement
|
|
);
|
|
resolveBuffer(response, id, constructor, streamState);
|
|
}
|
|
function flushComponentPerformance(
|
|
response$jscomp$0,
|
|
root,
|
|
trackIdx$jscomp$6,
|
|
trackTime,
|
|
parentEndTime
|
|
) {
|
|
if (!isArrayImpl(root._children)) {
|
|
var previousResult = root._children,
|
|
previousEndTime = previousResult.endTime;
|
|
if (
|
|
-Infinity < parentEndTime &&
|
|
parentEndTime < previousEndTime &&
|
|
null !== previousResult.component
|
|
) {
|
|
var componentInfo = previousResult.component,
|
|
trackIdx = trackIdx$jscomp$6,
|
|
startTime = parentEndTime;
|
|
if (supportsUserTiming && 0 <= previousEndTime && 10 > trackIdx) {
|
|
var color =
|
|
componentInfo.env === response$jscomp$0._rootEnvironmentName
|
|
? "primary-light"
|
|
: "secondary-light",
|
|
entryName = componentInfo.name + " [deduped]",
|
|
debugTask = componentInfo.debugTask;
|
|
debugTask
|
|
? debugTask.run(
|
|
console.timeStamp.bind(
|
|
console,
|
|
entryName,
|
|
0 > startTime ? 0 : startTime,
|
|
previousEndTime,
|
|
trackNames[trackIdx],
|
|
"Server Components \u269b",
|
|
color
|
|
)
|
|
)
|
|
: console.timeStamp(
|
|
entryName,
|
|
0 > startTime ? 0 : startTime,
|
|
previousEndTime,
|
|
trackNames[trackIdx],
|
|
"Server Components \u269b",
|
|
color
|
|
);
|
|
}
|
|
}
|
|
previousResult.track = trackIdx$jscomp$6;
|
|
return previousResult;
|
|
}
|
|
var children = root._children;
|
|
var debugInfo = root._debugInfo;
|
|
if (0 === debugInfo.length && "fulfilled" === root.status) {
|
|
var resolvedValue = resolveLazy(root.value);
|
|
"object" === typeof resolvedValue &&
|
|
null !== resolvedValue &&
|
|
(isArrayImpl(resolvedValue) ||
|
|
"function" === typeof resolvedValue[ASYNC_ITERATOR] ||
|
|
resolvedValue.$$typeof === REACT_ELEMENT_TYPE ||
|
|
resolvedValue.$$typeof === REACT_LAZY_TYPE) &&
|
|
isArrayImpl(resolvedValue._debugInfo) &&
|
|
(debugInfo = resolvedValue._debugInfo);
|
|
}
|
|
if (debugInfo) {
|
|
for (var startTime$jscomp$0 = 0, i = 0; i < debugInfo.length; i++) {
|
|
var info = debugInfo[i];
|
|
"number" === typeof info.time && (startTime$jscomp$0 = info.time);
|
|
if ("string" === typeof info.name) {
|
|
startTime$jscomp$0 < trackTime && trackIdx$jscomp$6++;
|
|
trackTime = startTime$jscomp$0;
|
|
break;
|
|
}
|
|
}
|
|
for (var _i4 = debugInfo.length - 1; 0 <= _i4; _i4--) {
|
|
var _info = debugInfo[_i4];
|
|
if ("number" === typeof _info.time && _info.time > parentEndTime) {
|
|
parentEndTime = _info.time;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
var result = {
|
|
track: trackIdx$jscomp$6,
|
|
endTime: -Infinity,
|
|
component: null
|
|
};
|
|
root._children = result;
|
|
for (
|
|
var childrenEndTime = -Infinity,
|
|
childTrackIdx = trackIdx$jscomp$6,
|
|
childTrackTime = trackTime,
|
|
_i5 = 0;
|
|
_i5 < children.length;
|
|
_i5++
|
|
) {
|
|
var childResult = flushComponentPerformance(
|
|
response$jscomp$0,
|
|
children[_i5],
|
|
childTrackIdx,
|
|
childTrackTime,
|
|
parentEndTime
|
|
);
|
|
null !== childResult.component &&
|
|
(result.component = childResult.component);
|
|
childTrackIdx = childResult.track;
|
|
var childEndTime = childResult.endTime;
|
|
childEndTime > childTrackTime && (childTrackTime = childEndTime);
|
|
childEndTime > childrenEndTime && (childrenEndTime = childEndTime);
|
|
}
|
|
if (debugInfo)
|
|
for (
|
|
var componentEndTime = 0,
|
|
isLastComponent = !0,
|
|
endTime = -1,
|
|
endTimeIdx = -1,
|
|
_i6 = debugInfo.length - 1;
|
|
0 <= _i6;
|
|
_i6--
|
|
) {
|
|
var _info2 = debugInfo[_i6];
|
|
if ("number" === typeof _info2.time) {
|
|
0 === componentEndTime && (componentEndTime = _info2.time);
|
|
var time = _info2.time;
|
|
if (-1 < endTimeIdx)
|
|
for (var j = endTimeIdx - 1; j > _i6; j--) {
|
|
var candidateInfo = debugInfo[j];
|
|
if ("string" === typeof candidateInfo.name) {
|
|
componentEndTime > childrenEndTime &&
|
|
(childrenEndTime = componentEndTime);
|
|
var componentInfo$jscomp$0 = candidateInfo,
|
|
response = response$jscomp$0,
|
|
componentInfo$jscomp$1 = componentInfo$jscomp$0,
|
|
trackIdx$jscomp$0 = trackIdx$jscomp$6,
|
|
startTime$jscomp$1 = time,
|
|
componentEndTime$jscomp$0 = componentEndTime,
|
|
childrenEndTime$jscomp$0 = childrenEndTime;
|
|
if (
|
|
isLastComponent &&
|
|
"rejected" === root.status &&
|
|
root.reason !== response._closedReason
|
|
) {
|
|
var componentInfo$jscomp$2 = componentInfo$jscomp$1,
|
|
trackIdx$jscomp$1 = trackIdx$jscomp$0,
|
|
startTime$jscomp$2 = startTime$jscomp$1,
|
|
childrenEndTime$jscomp$1 = childrenEndTime$jscomp$0,
|
|
error = root.reason;
|
|
if (supportsUserTiming) {
|
|
var env = componentInfo$jscomp$2.env,
|
|
name = componentInfo$jscomp$2.name,
|
|
entryName$jscomp$0 =
|
|
env === response._rootEnvironmentName ||
|
|
void 0 === env
|
|
? name
|
|
: name + " [" + env + "]",
|
|
measureName = "\u200b" + entryName$jscomp$0,
|
|
properties = [
|
|
[
|
|
"Error",
|
|
"object" === typeof error &&
|
|
null !== error &&
|
|
"string" === typeof error.message
|
|
? String(error.message)
|
|
: String(error)
|
|
]
|
|
];
|
|
null != componentInfo$jscomp$2.key &&
|
|
addValueToProperties(
|
|
"key",
|
|
componentInfo$jscomp$2.key,
|
|
properties,
|
|
0,
|
|
""
|
|
);
|
|
null != componentInfo$jscomp$2.props &&
|
|
addObjectToProperties(
|
|
componentInfo$jscomp$2.props,
|
|
properties,
|
|
0,
|
|
""
|
|
);
|
|
performance.measure(measureName, {
|
|
start: 0 > startTime$jscomp$2 ? 0 : startTime$jscomp$2,
|
|
end: childrenEndTime$jscomp$1,
|
|
detail: {
|
|
devtools: {
|
|
color: "error",
|
|
track: trackNames[trackIdx$jscomp$1],
|
|
trackGroup: "Server Components \u269b",
|
|
tooltipText: entryName$jscomp$0 + " Errored",
|
|
properties: properties
|
|
}
|
|
}
|
|
});
|
|
performance.clearMeasures(measureName);
|
|
}
|
|
} else {
|
|
var componentInfo$jscomp$3 = componentInfo$jscomp$1,
|
|
trackIdx$jscomp$2 = trackIdx$jscomp$0,
|
|
startTime$jscomp$3 = startTime$jscomp$1,
|
|
childrenEndTime$jscomp$2 = childrenEndTime$jscomp$0;
|
|
if (
|
|
supportsUserTiming &&
|
|
0 <= childrenEndTime$jscomp$2 &&
|
|
10 > trackIdx$jscomp$2
|
|
) {
|
|
var env$jscomp$0 = componentInfo$jscomp$3.env,
|
|
name$jscomp$0 = componentInfo$jscomp$3.name,
|
|
isPrimaryEnv =
|
|
env$jscomp$0 === response._rootEnvironmentName,
|
|
selfTime =
|
|
componentEndTime$jscomp$0 - startTime$jscomp$3,
|
|
color$jscomp$0 =
|
|
0.5 > selfTime
|
|
? isPrimaryEnv
|
|
? "primary-light"
|
|
: "secondary-light"
|
|
: 50 > selfTime
|
|
? isPrimaryEnv
|
|
? "primary"
|
|
: "secondary"
|
|
: 500 > selfTime
|
|
? isPrimaryEnv
|
|
? "primary-dark"
|
|
: "secondary-dark"
|
|
: "error",
|
|
debugTask$jscomp$0 = componentInfo$jscomp$3.debugTask,
|
|
measureName$jscomp$0 =
|
|
"\u200b" +
|
|
(isPrimaryEnv || void 0 === env$jscomp$0
|
|
? name$jscomp$0
|
|
: name$jscomp$0 + " [" + env$jscomp$0 + "]");
|
|
if (debugTask$jscomp$0) {
|
|
var properties$jscomp$0 = [];
|
|
null != componentInfo$jscomp$3.key &&
|
|
addValueToProperties(
|
|
"key",
|
|
componentInfo$jscomp$3.key,
|
|
properties$jscomp$0,
|
|
0,
|
|
""
|
|
);
|
|
null != componentInfo$jscomp$3.props &&
|
|
addObjectToProperties(
|
|
componentInfo$jscomp$3.props,
|
|
properties$jscomp$0,
|
|
0,
|
|
""
|
|
);
|
|
debugTask$jscomp$0.run(
|
|
performance.measure.bind(
|
|
performance,
|
|
measureName$jscomp$0,
|
|
{
|
|
start:
|
|
0 > startTime$jscomp$3 ? 0 : startTime$jscomp$3,
|
|
end: childrenEndTime$jscomp$2,
|
|
detail: {
|
|
devtools: {
|
|
color: color$jscomp$0,
|
|
track: trackNames[trackIdx$jscomp$2],
|
|
trackGroup: "Server Components \u269b",
|
|
properties: properties$jscomp$0
|
|
}
|
|
}
|
|
}
|
|
)
|
|
);
|
|
performance.clearMeasures(measureName$jscomp$0);
|
|
} else
|
|
console.timeStamp(
|
|
measureName$jscomp$0,
|
|
0 > startTime$jscomp$3 ? 0 : startTime$jscomp$3,
|
|
childrenEndTime$jscomp$2,
|
|
trackNames[trackIdx$jscomp$2],
|
|
"Server Components \u269b",
|
|
color$jscomp$0
|
|
);
|
|
}
|
|
}
|
|
componentEndTime = time;
|
|
result.component = componentInfo$jscomp$0;
|
|
isLastComponent = !1;
|
|
} else if (
|
|
candidateInfo.awaited &&
|
|
null != candidateInfo.awaited.env
|
|
) {
|
|
endTime > childrenEndTime && (childrenEndTime = endTime);
|
|
var asyncInfo = candidateInfo,
|
|
env$jscomp$1 = response$jscomp$0._rootEnvironmentName,
|
|
promise = asyncInfo.awaited.value;
|
|
if (promise) {
|
|
var thenable = promise;
|
|
switch (thenable.status) {
|
|
case "fulfilled":
|
|
logComponentAwait(
|
|
asyncInfo,
|
|
trackIdx$jscomp$6,
|
|
time,
|
|
endTime,
|
|
env$jscomp$1,
|
|
thenable.value
|
|
);
|
|
break;
|
|
case "rejected":
|
|
var asyncInfo$jscomp$0 = asyncInfo,
|
|
trackIdx$jscomp$3 = trackIdx$jscomp$6,
|
|
startTime$jscomp$4 = time,
|
|
endTime$jscomp$0 = endTime,
|
|
rootEnv = env$jscomp$1,
|
|
error$jscomp$0 = thenable.reason;
|
|
if (supportsUserTiming && 0 < endTime$jscomp$0) {
|
|
var description = getIODescription(error$jscomp$0),
|
|
entryName$jscomp$1 =
|
|
"await " +
|
|
getIOShortName(
|
|
asyncInfo$jscomp$0.awaited,
|
|
description,
|
|
asyncInfo$jscomp$0.env,
|
|
rootEnv
|
|
),
|
|
debugTask$jscomp$1 =
|
|
asyncInfo$jscomp$0.debugTask ||
|
|
asyncInfo$jscomp$0.awaited.debugTask;
|
|
if (debugTask$jscomp$1) {
|
|
var properties$jscomp$1 = [
|
|
[
|
|
"Rejected",
|
|
"object" === typeof error$jscomp$0 &&
|
|
null !== error$jscomp$0 &&
|
|
"string" === typeof error$jscomp$0.message
|
|
? String(error$jscomp$0.message)
|
|
: String(error$jscomp$0)
|
|
]
|
|
],
|
|
tooltipText =
|
|
getIOLongName(
|
|
asyncInfo$jscomp$0.awaited,
|
|
description,
|
|
asyncInfo$jscomp$0.env,
|
|
rootEnv
|
|
) + " Rejected";
|
|
debugTask$jscomp$1.run(
|
|
performance.measure.bind(
|
|
performance,
|
|
entryName$jscomp$1,
|
|
{
|
|
start:
|
|
0 > startTime$jscomp$4
|
|
? 0
|
|
: startTime$jscomp$4,
|
|
end: endTime$jscomp$0,
|
|
detail: {
|
|
devtools: {
|
|
color: "error",
|
|
track: trackNames[trackIdx$jscomp$3],
|
|
trackGroup: "Server Components \u269b",
|
|
properties: properties$jscomp$1,
|
|
tooltipText: tooltipText
|
|
}
|
|
}
|
|
}
|
|
)
|
|
);
|
|
performance.clearMeasures(entryName$jscomp$1);
|
|
} else
|
|
console.timeStamp(
|
|
entryName$jscomp$1,
|
|
0 > startTime$jscomp$4 ? 0 : startTime$jscomp$4,
|
|
endTime$jscomp$0,
|
|
trackNames[trackIdx$jscomp$3],
|
|
"Server Components \u269b",
|
|
"error"
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
logComponentAwait(
|
|
asyncInfo,
|
|
trackIdx$jscomp$6,
|
|
time,
|
|
endTime,
|
|
env$jscomp$1,
|
|
void 0
|
|
);
|
|
}
|
|
} else
|
|
logComponentAwait(
|
|
asyncInfo,
|
|
trackIdx$jscomp$6,
|
|
time,
|
|
endTime,
|
|
env$jscomp$1,
|
|
void 0
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
endTime = time;
|
|
for (var _j = debugInfo.length - 1; _j > _i6; _j--) {
|
|
var _candidateInfo = debugInfo[_j];
|
|
if ("string" === typeof _candidateInfo.name) {
|
|
componentEndTime > childrenEndTime &&
|
|
(childrenEndTime = componentEndTime);
|
|
var _componentInfo = _candidateInfo,
|
|
_env = response$jscomp$0._rootEnvironmentName,
|
|
componentInfo$jscomp$4 = _componentInfo,
|
|
trackIdx$jscomp$4 = trackIdx$jscomp$6,
|
|
startTime$jscomp$5 = time,
|
|
childrenEndTime$jscomp$3 = childrenEndTime;
|
|
if (supportsUserTiming) {
|
|
var env$jscomp$2 = componentInfo$jscomp$4.env,
|
|
name$jscomp$1 = componentInfo$jscomp$4.name,
|
|
entryName$jscomp$2 =
|
|
env$jscomp$2 === _env || void 0 === env$jscomp$2
|
|
? name$jscomp$1
|
|
: name$jscomp$1 + " [" + env$jscomp$2 + "]",
|
|
measureName$jscomp$1 = "\u200b" + entryName$jscomp$2,
|
|
properties$jscomp$2 = [
|
|
[
|
|
"Aborted",
|
|
"The stream was aborted before this Component finished rendering."
|
|
]
|
|
];
|
|
null != componentInfo$jscomp$4.key &&
|
|
addValueToProperties(
|
|
"key",
|
|
componentInfo$jscomp$4.key,
|
|
properties$jscomp$2,
|
|
0,
|
|
""
|
|
);
|
|
null != componentInfo$jscomp$4.props &&
|
|
addObjectToProperties(
|
|
componentInfo$jscomp$4.props,
|
|
properties$jscomp$2,
|
|
0,
|
|
""
|
|
);
|
|
performance.measure(measureName$jscomp$1, {
|
|
start: 0 > startTime$jscomp$5 ? 0 : startTime$jscomp$5,
|
|
end: childrenEndTime$jscomp$3,
|
|
detail: {
|
|
devtools: {
|
|
color: "warning",
|
|
track: trackNames[trackIdx$jscomp$4],
|
|
trackGroup: "Server Components \u269b",
|
|
tooltipText: entryName$jscomp$2 + " Aborted",
|
|
properties: properties$jscomp$2
|
|
}
|
|
}
|
|
});
|
|
performance.clearMeasures(measureName$jscomp$1);
|
|
}
|
|
componentEndTime = time;
|
|
result.component = _componentInfo;
|
|
isLastComponent = !1;
|
|
} else if (
|
|
_candidateInfo.awaited &&
|
|
null != _candidateInfo.awaited.env
|
|
) {
|
|
var _asyncInfo = _candidateInfo,
|
|
_env2 = response$jscomp$0._rootEnvironmentName;
|
|
_asyncInfo.awaited.end > endTime &&
|
|
(endTime = _asyncInfo.awaited.end);
|
|
endTime > childrenEndTime && (childrenEndTime = endTime);
|
|
var asyncInfo$jscomp$1 = _asyncInfo,
|
|
trackIdx$jscomp$5 = trackIdx$jscomp$6,
|
|
startTime$jscomp$6 = time,
|
|
endTime$jscomp$1 = endTime,
|
|
rootEnv$jscomp$0 = _env2;
|
|
if (supportsUserTiming && 0 < endTime$jscomp$1) {
|
|
var entryName$jscomp$3 =
|
|
"await " +
|
|
getIOShortName(
|
|
asyncInfo$jscomp$1.awaited,
|
|
"",
|
|
asyncInfo$jscomp$1.env,
|
|
rootEnv$jscomp$0
|
|
),
|
|
debugTask$jscomp$2 =
|
|
asyncInfo$jscomp$1.debugTask ||
|
|
asyncInfo$jscomp$1.awaited.debugTask;
|
|
if (debugTask$jscomp$2) {
|
|
var tooltipText$jscomp$0 =
|
|
getIOLongName(
|
|
asyncInfo$jscomp$1.awaited,
|
|
"",
|
|
asyncInfo$jscomp$1.env,
|
|
rootEnv$jscomp$0
|
|
) + " Aborted";
|
|
debugTask$jscomp$2.run(
|
|
performance.measure.bind(
|
|
performance,
|
|
entryName$jscomp$3,
|
|
{
|
|
start:
|
|
0 > startTime$jscomp$6 ? 0 : startTime$jscomp$6,
|
|
end: endTime$jscomp$1,
|
|
detail: {
|
|
devtools: {
|
|
color: "warning",
|
|
track: trackNames[trackIdx$jscomp$5],
|
|
trackGroup: "Server Components \u269b",
|
|
properties: [
|
|
[
|
|
"Aborted",
|
|
"The stream was aborted before this Promise resolved."
|
|
]
|
|
],
|
|
tooltipText: tooltipText$jscomp$0
|
|
}
|
|
}
|
|
}
|
|
)
|
|
);
|
|
performance.clearMeasures(entryName$jscomp$3);
|
|
} else
|
|
console.timeStamp(
|
|
entryName$jscomp$3,
|
|
0 > startTime$jscomp$6 ? 0 : startTime$jscomp$6,
|
|
endTime$jscomp$1,
|
|
trackNames[trackIdx$jscomp$5],
|
|
"Server Components \u269b",
|
|
"warning"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
endTime = time;
|
|
endTimeIdx = _i6;
|
|
}
|
|
}
|
|
result.endTime = childrenEndTime;
|
|
return result;
|
|
}
|
|
function flushInitialRenderPerformance(response) {
|
|
if (response._replayConsole) {
|
|
var rootChunk = getChunk(response, 0);
|
|
isArrayImpl(rootChunk._children) &&
|
|
(markAllTracksInOrder(),
|
|
flushComponentPerformance(
|
|
response,
|
|
rootChunk,
|
|
0,
|
|
-Infinity,
|
|
-Infinity
|
|
));
|
|
}
|
|
}
|
|
function processFullBinaryRow(
|
|
response,
|
|
streamState,
|
|
id,
|
|
tag,
|
|
buffer,
|
|
chunk
|
|
) {
|
|
switch (tag) {
|
|
case 65:
|
|
resolveBuffer(
|
|
response,
|
|
id,
|
|
mergeBuffer(buffer, chunk).buffer,
|
|
streamState
|
|
);
|
|
return;
|
|
case 79:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Int8Array,
|
|
1,
|
|
streamState
|
|
);
|
|
return;
|
|
case 111:
|
|
resolveBuffer(
|
|
response,
|
|
id,
|
|
0 === buffer.length ? chunk : mergeBuffer(buffer, chunk),
|
|
streamState
|
|
);
|
|
return;
|
|
case 85:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Uint8ClampedArray,
|
|
1,
|
|
streamState
|
|
);
|
|
return;
|
|
case 83:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Int16Array,
|
|
2,
|
|
streamState
|
|
);
|
|
return;
|
|
case 115:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Uint16Array,
|
|
2,
|
|
streamState
|
|
);
|
|
return;
|
|
case 76:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Int32Array,
|
|
4,
|
|
streamState
|
|
);
|
|
return;
|
|
case 108:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Uint32Array,
|
|
4,
|
|
streamState
|
|
);
|
|
return;
|
|
case 71:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Float32Array,
|
|
4,
|
|
streamState
|
|
);
|
|
return;
|
|
case 103:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
Float64Array,
|
|
8,
|
|
streamState
|
|
);
|
|
return;
|
|
case 77:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
BigInt64Array,
|
|
8,
|
|
streamState
|
|
);
|
|
return;
|
|
case 109:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
BigUint64Array,
|
|
8,
|
|
streamState
|
|
);
|
|
return;
|
|
case 86:
|
|
resolveTypedArray(
|
|
response,
|
|
id,
|
|
buffer,
|
|
chunk,
|
|
DataView,
|
|
1,
|
|
streamState
|
|
);
|
|
return;
|
|
}
|
|
for (
|
|
var stringDecoder = response._stringDecoder, row = "", i = 0;
|
|
i < buffer.length;
|
|
i++
|
|
)
|
|
row += stringDecoder.decode(buffer[i], decoderOptions);
|
|
row += stringDecoder.decode(chunk);
|
|
processFullStringRow(response, streamState, id, tag, row);
|
|
}
|
|
function processFullStringRow(response, streamState, id, tag, row) {
|
|
switch (tag) {
|
|
case 73:
|
|
resolveModule(response, id, row, streamState);
|
|
break;
|
|
case 72:
|
|
id = row[0];
|
|
streamState = row.slice(1);
|
|
response = JSON.parse(streamState, response._fromJSON);
|
|
streamState = ReactDOMSharedInternals.d;
|
|
switch (id) {
|
|
case "D":
|
|
streamState.D(response);
|
|
break;
|
|
case "C":
|
|
"string" === typeof response
|
|
? streamState.C(response)
|
|
: streamState.C(response[0], response[1]);
|
|
break;
|
|
case "L":
|
|
id = response[0];
|
|
row = response[1];
|
|
3 === response.length
|
|
? streamState.L(id, row, response[2])
|
|
: streamState.L(id, row);
|
|
break;
|
|
case "m":
|
|
"string" === typeof response
|
|
? streamState.m(response)
|
|
: streamState.m(response[0], response[1]);
|
|
break;
|
|
case "X":
|
|
"string" === typeof response
|
|
? streamState.X(response)
|
|
: streamState.X(response[0], response[1]);
|
|
break;
|
|
case "S":
|
|
"string" === typeof response
|
|
? streamState.S(response)
|
|
: streamState.S(
|
|
response[0],
|
|
0 === response[1] ? void 0 : response[1],
|
|
3 === response.length ? response[2] : void 0
|
|
);
|
|
break;
|
|
case "M":
|
|
"string" === typeof response
|
|
? streamState.M(response)
|
|
: streamState.M(response[0], response[1]);
|
|
}
|
|
break;
|
|
case 69:
|
|
tag = response._chunks;
|
|
var chunk = tag.get(id);
|
|
row = JSON.parse(row);
|
|
var error = resolveErrorDev(response, row);
|
|
error.digest = row.digest;
|
|
chunk
|
|
? (resolveChunkDebugInfo(response, streamState, chunk),
|
|
triggerErrorOnChunk(response, chunk, error))
|
|
: ((row = new ReactPromise("rejected", null, error)),
|
|
resolveChunkDebugInfo(response, streamState, row),
|
|
tag.set(id, row));
|
|
break;
|
|
case 84:
|
|
tag = response._chunks;
|
|
(chunk = tag.get(id)) && "pending" !== chunk.status
|
|
? chunk.reason.enqueueValue(row)
|
|
: (chunk && releasePendingChunk(response, chunk),
|
|
(row = new ReactPromise("fulfilled", row, null)),
|
|
resolveChunkDebugInfo(response, streamState, row),
|
|
tag.set(id, row));
|
|
break;
|
|
case 78:
|
|
response._timeOrigin = +row - performance.timeOrigin;
|
|
break;
|
|
case 68:
|
|
id = getChunk(response, id);
|
|
"fulfilled" !== id.status &&
|
|
"rejected" !== id.status &&
|
|
"halted" !== id.status &&
|
|
"blocked" !== id.status &&
|
|
"resolved_module" !== id.status &&
|
|
((streamState = id._debugChunk),
|
|
(tag = createResolvedModelChunk(response, row)),
|
|
(tag._debugChunk = streamState),
|
|
(id._debugChunk = tag),
|
|
initializeDebugChunk(response, id),
|
|
"blocked" !== tag.status ||
|
|
(void 0 !== response._debugChannel &&
|
|
response._debugChannel.hasReadable) ||
|
|
'"' !== row[0] ||
|
|
"$" !== row[1] ||
|
|
((streamState = row.slice(2, row.length - 1).split(":")),
|
|
(streamState = parseInt(streamState[0], 16)),
|
|
"pending" === getChunk(response, streamState).status &&
|
|
(id._debugChunk = null)));
|
|
break;
|
|
case 74:
|
|
resolveIOInfo(response, id, row);
|
|
break;
|
|
case 87:
|
|
resolveConsoleEntry(response, row);
|
|
break;
|
|
case 82:
|
|
startReadableStream(response, id, void 0, streamState);
|
|
break;
|
|
case 114:
|
|
startReadableStream(response, id, "bytes", streamState);
|
|
break;
|
|
case 88:
|
|
startAsyncIterable(response, id, !1, streamState);
|
|
break;
|
|
case 120:
|
|
startAsyncIterable(response, id, !0, streamState);
|
|
break;
|
|
case 67:
|
|
(id = response._chunks.get(id)) &&
|
|
"fulfilled" === id.status &&
|
|
(0 === --response._pendingChunks &&
|
|
(response._weakResponse.response = null),
|
|
id.reason.close("" === row ? '"$undefined"' : row));
|
|
break;
|
|
default:
|
|
if ("" === row) {
|
|
if (
|
|
((streamState = response._chunks),
|
|
(row = streamState.get(id)) ||
|
|
streamState.set(id, (row = createPendingChunk(response))),
|
|
"pending" === row.status || "blocked" === row.status)
|
|
)
|
|
releasePendingChunk(response, row),
|
|
(response = row),
|
|
(response.status = "halted"),
|
|
(response.value = null),
|
|
(response.reason = null);
|
|
} else
|
|
(tag = response._chunks),
|
|
(chunk = tag.get(id))
|
|
? (resolveChunkDebugInfo(response, streamState, chunk),
|
|
resolveModelChunk(response, chunk, row))
|
|
: ((row = createResolvedModelChunk(response, row)),
|
|
resolveChunkDebugInfo(response, streamState, row),
|
|
tag.set(id, row));
|
|
}
|
|
}
|
|
function processBinaryChunk(weakResponse, streamState, chunk) {
|
|
if (void 0 !== weakResponse.weak.deref()) {
|
|
weakResponse = unwrapWeakResponse(weakResponse);
|
|
var i = 0,
|
|
rowState = streamState._rowState,
|
|
rowID = streamState._rowID,
|
|
rowTag = streamState._rowTag,
|
|
rowLength = streamState._rowLength,
|
|
buffer = streamState._buffer,
|
|
chunkLength = chunk.length;
|
|
for (
|
|
incrementChunkDebugInfo(streamState, chunkLength);
|
|
i < chunkLength;
|
|
|
|
) {
|
|
var lastIdx = -1;
|
|
switch (rowState) {
|
|
case 0:
|
|
lastIdx = chunk[i++];
|
|
58 === lastIdx
|
|
? (rowState = 1)
|
|
: (rowID =
|
|
(rowID << 4) |
|
|
(96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
|
|
continue;
|
|
case 1:
|
|
rowState = chunk[i];
|
|
84 === rowState ||
|
|
65 === rowState ||
|
|
79 === rowState ||
|
|
111 === rowState ||
|
|
98 === rowState ||
|
|
85 === rowState ||
|
|
83 === rowState ||
|
|
115 === rowState ||
|
|
76 === rowState ||
|
|
108 === rowState ||
|
|
71 === rowState ||
|
|
103 === rowState ||
|
|
77 === rowState ||
|
|
109 === rowState ||
|
|
86 === rowState
|
|
? ((rowTag = rowState), (rowState = 2), i++)
|
|
: (64 < rowState && 91 > rowState) ||
|
|
35 === rowState ||
|
|
114 === rowState ||
|
|
120 === rowState
|
|
? ((rowTag = rowState), (rowState = 3), i++)
|
|
: ((rowTag = 0), (rowState = 3));
|
|
continue;
|
|
case 2:
|
|
lastIdx = chunk[i++];
|
|
44 === lastIdx
|
|
? (rowState = 4)
|
|
: (rowLength =
|
|
(rowLength << 4) |
|
|
(96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
|
|
continue;
|
|
case 3:
|
|
lastIdx = chunk.indexOf(10, i);
|
|
break;
|
|
case 4:
|
|
(lastIdx = i + rowLength),
|
|
lastIdx > chunk.length && (lastIdx = -1);
|
|
}
|
|
var offset = chunk.byteOffset + i;
|
|
if (-1 < lastIdx)
|
|
(rowLength = new Uint8Array(chunk.buffer, offset, lastIdx - i)),
|
|
98 === rowTag
|
|
? resolveBuffer(
|
|
weakResponse,
|
|
rowID,
|
|
lastIdx === chunkLength ? rowLength : rowLength.slice(),
|
|
streamState
|
|
)
|
|
: processFullBinaryRow(
|
|
weakResponse,
|
|
streamState,
|
|
rowID,
|
|
rowTag,
|
|
buffer,
|
|
rowLength
|
|
),
|
|
(i = lastIdx),
|
|
3 === rowState && i++,
|
|
(rowLength = rowID = rowTag = rowState = 0),
|
|
(buffer.length = 0);
|
|
else {
|
|
chunk = new Uint8Array(chunk.buffer, offset, chunk.byteLength - i);
|
|
98 === rowTag
|
|
? ((rowLength -= chunk.byteLength),
|
|
resolveBuffer(weakResponse, rowID, chunk, streamState))
|
|
: (buffer.push(chunk), (rowLength -= chunk.byteLength));
|
|
break;
|
|
}
|
|
}
|
|
streamState._rowState = rowState;
|
|
streamState._rowID = rowID;
|
|
streamState._rowTag = rowTag;
|
|
streamState._rowLength = rowLength;
|
|
}
|
|
}
|
|
function createFromJSONCallback(response) {
|
|
return function (key, value) {
|
|
if ("__proto__" !== key) {
|
|
if ("string" === typeof value)
|
|
return parseModelString(response, this, key, value);
|
|
if ("object" === typeof value && null !== value) {
|
|
if (value[0] === REACT_ELEMENT_TYPE)
|
|
b: {
|
|
var owner = value[4],
|
|
stack = value[5];
|
|
key = value[6];
|
|
value = {
|
|
$$typeof: REACT_ELEMENT_TYPE,
|
|
type: value[1],
|
|
key: value[2],
|
|
props: value[3],
|
|
_owner: void 0 === owner ? null : owner
|
|
};
|
|
Object.defineProperty(value, "ref", {
|
|
enumerable: !1,
|
|
get: nullRefGetter
|
|
});
|
|
value._store = {};
|
|
Object.defineProperty(value._store, "validated", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: key
|
|
});
|
|
Object.defineProperty(value, "_debugInfo", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: null
|
|
});
|
|
Object.defineProperty(value, "_debugStack", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: void 0 === stack ? null : stack
|
|
});
|
|
Object.defineProperty(value, "_debugTask", {
|
|
configurable: !1,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
value: null
|
|
});
|
|
if (null !== initializingHandler) {
|
|
owner = initializingHandler;
|
|
initializingHandler = owner.parent;
|
|
if (owner.errored) {
|
|
stack = new ReactPromise("rejected", null, owner.reason);
|
|
initializeElement(response, value, null);
|
|
owner = {
|
|
name: getComponentNameFromType(value.type) || "",
|
|
owner: value._owner
|
|
};
|
|
owner.debugStack = value._debugStack;
|
|
supportsCreateTask && (owner.debugTask = value._debugTask);
|
|
stack._debugInfo = [owner];
|
|
key = createLazyChunkWrapper(stack, key);
|
|
break b;
|
|
}
|
|
if (0 < owner.deps) {
|
|
stack = new ReactPromise("blocked", null, null);
|
|
owner.value = value;
|
|
owner.chunk = stack;
|
|
key = createLazyChunkWrapper(stack, key);
|
|
value = initializeElement.bind(null, response, value, key);
|
|
stack.then(value, value);
|
|
break b;
|
|
}
|
|
}
|
|
initializeElement(response, value, null);
|
|
key = value;
|
|
}
|
|
else key = value;
|
|
return key;
|
|
}
|
|
return value;
|
|
}
|
|
};
|
|
}
|
|
function close(weakResponse) {
|
|
reportGlobalError(weakResponse, Error("Connection closed."));
|
|
}
|
|
function createDebugCallbackFromWritableStream(debugWritable) {
|
|
var textEncoder = new TextEncoder(),
|
|
writer = debugWritable.getWriter();
|
|
return function (message) {
|
|
"" === message
|
|
? writer.close()
|
|
: writer
|
|
.write(textEncoder.encode(message + "\n"))
|
|
.catch(console.error);
|
|
};
|
|
}
|
|
function createResponseFromOptions(options) {
|
|
var debugChannel =
|
|
options && void 0 !== options.debugChannel
|
|
? {
|
|
hasReadable: void 0 !== options.debugChannel.readable,
|
|
callback:
|
|
void 0 !== options.debugChannel.writable
|
|
? createDebugCallbackFromWritableStream(
|
|
options.debugChannel.writable
|
|
)
|
|
: null
|
|
}
|
|
: void 0;
|
|
return new ResponseInstance(
|
|
null,
|
|
null,
|
|
null,
|
|
options && options.callServer ? options.callServer : void 0,
|
|
void 0,
|
|
void 0,
|
|
options && options.temporaryReferences
|
|
? options.temporaryReferences
|
|
: void 0,
|
|
options && options.findSourceMapURL ? options.findSourceMapURL : void 0,
|
|
options ? !1 !== options.replayConsoleLogs : !0,
|
|
options && options.environmentName ? options.environmentName : void 0,
|
|
options && null != options.startTime ? options.startTime : void 0,
|
|
options && null != options.endTime ? options.endTime : void 0,
|
|
debugChannel
|
|
)._weakResponse;
|
|
}
|
|
function startReadingFromUniversalStream(
|
|
response$jscomp$0,
|
|
stream,
|
|
onDone
|
|
) {
|
|
function progress(_ref) {
|
|
var value = _ref.value;
|
|
if (_ref.done) return onDone();
|
|
if (value instanceof ArrayBuffer)
|
|
processBinaryChunk(
|
|
response$jscomp$0,
|
|
streamState,
|
|
new Uint8Array(value)
|
|
);
|
|
else if ("string" === typeof value) {
|
|
if (
|
|
((_ref = streamState), void 0 !== response$jscomp$0.weak.deref())
|
|
) {
|
|
var response = unwrapWeakResponse(response$jscomp$0),
|
|
i = 0,
|
|
rowState = _ref._rowState,
|
|
rowID = _ref._rowID,
|
|
rowTag = _ref._rowTag,
|
|
rowLength = _ref._rowLength,
|
|
buffer = _ref._buffer,
|
|
chunkLength = value.length;
|
|
for (
|
|
incrementChunkDebugInfo(_ref, chunkLength);
|
|
i < chunkLength;
|
|
|
|
) {
|
|
var lastIdx = -1;
|
|
switch (rowState) {
|
|
case 0:
|
|
lastIdx = value.charCodeAt(i++);
|
|
58 === lastIdx
|
|
? (rowState = 1)
|
|
: (rowID =
|
|
(rowID << 4) |
|
|
(96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
|
|
continue;
|
|
case 1:
|
|
rowState = value.charCodeAt(i);
|
|
84 === rowState ||
|
|
65 === rowState ||
|
|
79 === rowState ||
|
|
111 === rowState ||
|
|
85 === rowState ||
|
|
83 === rowState ||
|
|
115 === rowState ||
|
|
76 === rowState ||
|
|
108 === rowState ||
|
|
71 === rowState ||
|
|
103 === rowState ||
|
|
77 === rowState ||
|
|
109 === rowState ||
|
|
86 === rowState
|
|
? ((rowTag = rowState), (rowState = 2), i++)
|
|
: (64 < rowState && 91 > rowState) ||
|
|
114 === rowState ||
|
|
120 === rowState
|
|
? ((rowTag = rowState), (rowState = 3), i++)
|
|
: ((rowTag = 0), (rowState = 3));
|
|
continue;
|
|
case 2:
|
|
lastIdx = value.charCodeAt(i++);
|
|
44 === lastIdx
|
|
? (rowState = 4)
|
|
: (rowLength =
|
|
(rowLength << 4) |
|
|
(96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
|
|
continue;
|
|
case 3:
|
|
lastIdx = value.indexOf("\n", i);
|
|
break;
|
|
case 4:
|
|
if (84 !== rowTag)
|
|
throw Error(
|
|
"Binary RSC chunks cannot be encoded as strings. This is a bug in the wiring of the React streams."
|
|
);
|
|
if (rowLength < value.length || value.length > 3 * rowLength)
|
|
throw Error(
|
|
"String chunks need to be passed in their original shape. Not split into smaller string chunks. This is a bug in the wiring of the React streams."
|
|
);
|
|
lastIdx = value.length;
|
|
}
|
|
if (-1 < lastIdx) {
|
|
if (0 < buffer.length)
|
|
throw Error(
|
|
"String chunks need to be passed in their original shape. Not split into smaller string chunks. This is a bug in the wiring of the React streams."
|
|
);
|
|
i = value.slice(i, lastIdx);
|
|
processFullStringRow(response, _ref, rowID, rowTag, i);
|
|
i = lastIdx;
|
|
3 === rowState && i++;
|
|
rowLength = rowID = rowTag = rowState = 0;
|
|
buffer.length = 0;
|
|
} else if (value.length !== i)
|
|
throw Error(
|
|
"String chunks need to be passed in their original shape. Not split into smaller string chunks. This is a bug in the wiring of the React streams."
|
|
);
|
|
}
|
|
_ref._rowState = rowState;
|
|
_ref._rowID = rowID;
|
|
_ref._rowTag = rowTag;
|
|
_ref._rowLength = rowLength;
|
|
}
|
|
} else processBinaryChunk(response$jscomp$0, streamState, value);
|
|
return reader.read().then(progress).catch(error);
|
|
}
|
|
function error(e) {
|
|
reportGlobalError(response$jscomp$0, e);
|
|
}
|
|
var streamState = createStreamState(response$jscomp$0, stream),
|
|
reader = stream.getReader();
|
|
reader.read().then(progress).catch(error);
|
|
}
|
|
function startReadingFromStream(response, stream, onDone, debugValue) {
|
|
function progress(_ref2) {
|
|
var value = _ref2.value;
|
|
if (_ref2.done) return onDone();
|
|
processBinaryChunk(response, streamState, value);
|
|
return reader.read().then(progress).catch(error);
|
|
}
|
|
function error(e) {
|
|
reportGlobalError(response, e);
|
|
}
|
|
var streamState = createStreamState(response, debugValue),
|
|
reader = stream.getReader();
|
|
reader.read().then(progress).catch(error);
|
|
}
|
|
var React = require("react"),
|
|
ReactDOM = require("react-dom"),
|
|
decoderOptions = { stream: !0 },
|
|
bind = Function.prototype.bind,
|
|
hasOwnProperty = Object.prototype.hasOwnProperty,
|
|
chunkCache = new Map(),
|
|
chunkMap = new Map(),
|
|
webpackGetChunkFilename = __webpack_require__.u;
|
|
__webpack_require__.u = function (chunkId) {
|
|
var flightChunk = chunkMap.get(chunkId);
|
|
return void 0 !== flightChunk
|
|
? flightChunk
|
|
: webpackGetChunkFilename(chunkId);
|
|
};
|
|
var chunkIOInfoCache = new Map(),
|
|
ReactDOMSharedInternals =
|
|
ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
|
|
REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
|
|
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
|
|
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
|
|
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
|
|
REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
|
|
REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
|
|
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
|
|
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
|
|
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
|
|
REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
|
|
REACT_MEMO_TYPE = Symbol.for("react.memo"),
|
|
REACT_LAZY_TYPE = Symbol.for("react.lazy"),
|
|
REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
|
|
REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
|
|
MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
|
|
ASYNC_ITERATOR = Symbol.asyncIterator,
|
|
isArrayImpl = Array.isArray,
|
|
getPrototypeOf = Object.getPrototypeOf,
|
|
jsxPropsParents = new WeakMap(),
|
|
jsxChildrenParents = new WeakMap(),
|
|
CLIENT_REFERENCE_TAG = Symbol.for("react.client.reference"),
|
|
ObjectPrototype = Object.prototype,
|
|
knownServerReferences = new WeakMap(),
|
|
fakeServerFunctionIdx = 0,
|
|
v8FrameRegExp =
|
|
/^ {3} at (?:(.+) \((.+):(\d+):(\d+)\)|(?:async )?(.+):(\d+):(\d+))$/,
|
|
jscSpiderMonkeyFrameRegExp = /(?:(.*)@)?(.*):(\d+):(\d+)/,
|
|
REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
|
|
supportsUserTiming =
|
|
"undefined" !== typeof console &&
|
|
"function" === typeof console.timeStamp &&
|
|
"undefined" !== typeof performance &&
|
|
"function" === typeof performance.measure,
|
|
trackNames =
|
|
"Primary Parallel Parallel\u200b Parallel\u200b\u200b Parallel\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b".split(
|
|
" "
|
|
),
|
|
prefix,
|
|
suffix;
|
|
new ("function" === typeof WeakMap ? WeakMap : Map)();
|
|
var ReactSharedInteralsServer =
|
|
React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
|
|
ReactSharedInternals =
|
|
React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE ||
|
|
ReactSharedInteralsServer;
|
|
ReactPromise.prototype = Object.create(Promise.prototype);
|
|
ReactPromise.prototype.then = function (resolve, reject) {
|
|
var _this = this;
|
|
switch (this.status) {
|
|
case "resolved_model":
|
|
initializeModelChunk(this);
|
|
break;
|
|
case "resolved_module":
|
|
initializeModuleChunk(this);
|
|
}
|
|
var resolveCallback = resolve,
|
|
rejectCallback = reject,
|
|
wrapperPromise = new Promise(function (res, rej) {
|
|
resolve = function (value) {
|
|
wrapperPromise._debugInfo = _this._debugInfo;
|
|
res(value);
|
|
};
|
|
reject = function (reason) {
|
|
wrapperPromise._debugInfo = _this._debugInfo;
|
|
rej(reason);
|
|
};
|
|
});
|
|
wrapperPromise.then(resolveCallback, rejectCallback);
|
|
switch (this.status) {
|
|
case "fulfilled":
|
|
"function" === typeof resolve && resolve(this.value);
|
|
break;
|
|
case "pending":
|
|
case "blocked":
|
|
"function" === typeof resolve &&
|
|
(null === this.value && (this.value = []),
|
|
this.value.push(resolve));
|
|
"function" === typeof reject &&
|
|
(null === this.reason && (this.reason = []),
|
|
this.reason.push(reject));
|
|
break;
|
|
case "halted":
|
|
break;
|
|
default:
|
|
"function" === typeof reject && reject(this.reason);
|
|
}
|
|
};
|
|
var debugChannelRegistry =
|
|
"function" === typeof FinalizationRegistry
|
|
? new FinalizationRegistry(closeDebugChannel)
|
|
: null,
|
|
initializingHandler = null,
|
|
initializingChunk = null,
|
|
mightHaveStaticConstructor = /\bclass\b.*\bstatic\b/,
|
|
MIN_CHUNK_SIZE = 65536,
|
|
supportsCreateTask = !!console.createTask,
|
|
fakeFunctionCache = new Map(),
|
|
fakeFunctionIdx = 0,
|
|
createFakeJSXCallStack = {
|
|
react_stack_bottom_frame: function (response, stack, environmentName) {
|
|
return buildFakeCallStack(
|
|
response,
|
|
stack,
|
|
environmentName,
|
|
!1,
|
|
fakeJSXCallSite
|
|
)();
|
|
}
|
|
},
|
|
createFakeJSXCallStackInDEV =
|
|
createFakeJSXCallStack.react_stack_bottom_frame.bind(
|
|
createFakeJSXCallStack
|
|
),
|
|
currentOwnerInDEV = null,
|
|
replayConsoleWithCallStack = {
|
|
react_stack_bottom_frame: function (response, payload) {
|
|
var methodName = payload[0],
|
|
stackTrace = payload[1],
|
|
owner = payload[2],
|
|
env = payload[3];
|
|
payload = payload.slice(4);
|
|
var prevStack = ReactSharedInternals.getCurrentStack;
|
|
ReactSharedInternals.getCurrentStack = getCurrentStackInDEV;
|
|
currentOwnerInDEV = null === owner ? response._debugRootOwner : owner;
|
|
try {
|
|
a: {
|
|
var offset = 0;
|
|
switch (methodName) {
|
|
case "dir":
|
|
case "dirxml":
|
|
case "groupEnd":
|
|
case "table":
|
|
var JSCompiler_inline_result = bind.apply(
|
|
console[methodName],
|
|
[console].concat(payload)
|
|
);
|
|
break a;
|
|
case "assert":
|
|
offset = 1;
|
|
}
|
|
var newArgs = payload.slice(0);
|
|
"string" === typeof newArgs[offset]
|
|
? newArgs.splice(
|
|
offset,
|
|
1,
|
|
"%c%s%c " + newArgs[offset],
|
|
"background: #e6e6e6;background: light-dark(rgba(0,0,0,0.1), rgba(255,255,255,0.25));color: #000000;color: light-dark(#000000, #ffffff);border-radius: 2px",
|
|
" " + env + " ",
|
|
""
|
|
)
|
|
: newArgs.splice(
|
|
offset,
|
|
0,
|
|
"%c%s%c",
|
|
"background: #e6e6e6;background: light-dark(rgba(0,0,0,0.1), rgba(255,255,255,0.25));color: #000000;color: light-dark(#000000, #ffffff);border-radius: 2px",
|
|
" " + env + " ",
|
|
""
|
|
);
|
|
newArgs.unshift(console);
|
|
JSCompiler_inline_result = bind.apply(
|
|
console[methodName],
|
|
newArgs
|
|
);
|
|
}
|
|
var callStack = buildFakeCallStack(
|
|
response,
|
|
stackTrace,
|
|
env,
|
|
!1,
|
|
JSCompiler_inline_result
|
|
);
|
|
if (null != owner) {
|
|
var task = initializeFakeTask(response, owner);
|
|
initializeFakeStack(response, owner);
|
|
if (null !== task) {
|
|
task.run(callStack);
|
|
return;
|
|
}
|
|
}
|
|
var rootTask = getRootTask(response, env);
|
|
null != rootTask ? rootTask.run(callStack) : callStack();
|
|
} finally {
|
|
(currentOwnerInDEV = null),
|
|
(ReactSharedInternals.getCurrentStack = prevStack);
|
|
}
|
|
}
|
|
},
|
|
replayConsoleWithCallStackInDEV =
|
|
replayConsoleWithCallStack.react_stack_bottom_frame.bind(
|
|
replayConsoleWithCallStack
|
|
);
|
|
(function (internals) {
|
|
if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
|
|
var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
|
|
if (hook.isDisabled || !hook.supportsFlight) return !0;
|
|
try {
|
|
hook.inject(internals);
|
|
} catch (err) {
|
|
console.error("React instrumentation encountered an error: %o.", err);
|
|
}
|
|
return hook.checkDCE ? !0 : !1;
|
|
})({
|
|
bundleType: 1,
|
|
version: "19.3.0-experimental-cbec50fd-20260122",
|
|
rendererPackageName: "react-server-dom-webpack",
|
|
currentDispatcherRef: ReactSharedInternals,
|
|
reconcilerVersion: "19.3.0-experimental-cbec50fd-20260122",
|
|
getCurrentComponentInfo: function () {
|
|
return currentOwnerInDEV;
|
|
}
|
|
});
|
|
exports.createFromFetch = function (promiseForResponse, options) {
|
|
var response = createResponseFromOptions(options);
|
|
promiseForResponse.then(
|
|
function (r) {
|
|
if (
|
|
options &&
|
|
options.debugChannel &&
|
|
options.debugChannel.readable
|
|
) {
|
|
var streamDoneCount = 0,
|
|
handleDone = function () {
|
|
2 === ++streamDoneCount && close(response);
|
|
};
|
|
startReadingFromUniversalStream(
|
|
response,
|
|
options.debugChannel.readable,
|
|
handleDone
|
|
);
|
|
startReadingFromStream(response, r.body, handleDone, r);
|
|
} else
|
|
startReadingFromStream(
|
|
response,
|
|
r.body,
|
|
close.bind(null, response),
|
|
r
|
|
);
|
|
},
|
|
function (e) {
|
|
reportGlobalError(response, e);
|
|
}
|
|
);
|
|
return getRoot(response);
|
|
};
|
|
exports.createFromReadableStream = function (stream, options) {
|
|
var response = createResponseFromOptions(options);
|
|
if (options && options.debugChannel && options.debugChannel.readable) {
|
|
var streamDoneCount = 0,
|
|
handleDone = function () {
|
|
2 === ++streamDoneCount && close(response);
|
|
};
|
|
startReadingFromUniversalStream(
|
|
response,
|
|
options.debugChannel.readable,
|
|
handleDone
|
|
);
|
|
startReadingFromStream(response, stream, handleDone, stream);
|
|
} else
|
|
startReadingFromStream(
|
|
response,
|
|
stream,
|
|
close.bind(null, response),
|
|
stream
|
|
);
|
|
return getRoot(response);
|
|
};
|
|
exports.createServerReference = function (
|
|
id,
|
|
callServer,
|
|
encodeFormAction,
|
|
findSourceMapURL,
|
|
functionName
|
|
) {
|
|
function action() {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
return callServer(id, args);
|
|
}
|
|
var location = parseStackLocation(Error("react-stack-top-frame"));
|
|
if (null !== location) {
|
|
encodeFormAction = location[1];
|
|
var line = location[2];
|
|
location = location[3];
|
|
findSourceMapURL =
|
|
null == findSourceMapURL
|
|
? null
|
|
: findSourceMapURL(encodeFormAction, "Client");
|
|
action = createFakeServerFunction(
|
|
functionName || "",
|
|
encodeFormAction,
|
|
findSourceMapURL,
|
|
line,
|
|
location,
|
|
"Client",
|
|
action
|
|
);
|
|
}
|
|
registerBoundServerReference(action, id, null);
|
|
return action;
|
|
};
|
|
exports.createTemporaryReferenceSet = function () {
|
|
return new Map();
|
|
};
|
|
exports.encodeReply = function (value, options) {
|
|
return new Promise(function (resolve, reject) {
|
|
var abort = processReply(
|
|
value,
|
|
"",
|
|
options && options.temporaryReferences
|
|
? options.temporaryReferences
|
|
: void 0,
|
|
resolve,
|
|
reject
|
|
);
|
|
if (options && options.signal) {
|
|
var signal = options.signal;
|
|
if (signal.aborted) abort(signal.reason);
|
|
else {
|
|
var listener = function () {
|
|
abort(signal.reason);
|
|
signal.removeEventListener("abort", listener);
|
|
};
|
|
signal.addEventListener("abort", listener);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
exports.registerServerReference = function (reference, id) {
|
|
registerBoundServerReference(reference, id, null);
|
|
return reference;
|
|
};
|
|
})();
|