@vitejs/plugin-rsc 0.5.33 → 0.5.35

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-client.edge.production.js

@@ -123,7 +123,12 @@ function prepareDestinationWithChunks(moduleLoading, chunks, nonce$jscomp$0) {
       JSCompiler_temp_const$jscomp$0.call(
         JSCompiler_temp_const,
         JSCompiler_temp_const$jscomp$1,
-        { crossOrigin: JSCompiler_inline_result, nonce: nonce }
+        {
+          crossOrigin: JSCompiler_inline_result,
+          integrity: void 0,
+          fetchPriority: void 0,
+          nonce: nonce
+        }
       );
     }
 }
@@ -142,7 +147,7 @@ function getIteratorFn(maybeIterable) {
 var ASYNC_ITERATOR = Symbol.asyncIterator,
   isArrayImpl = Array.isArray,
   getPrototypeOf = Object.getPrototypeOf,
-  ObjectPrototype = Object.prototype,
+  ObjectPrototype$1 = Object.prototype,
   knownServerReferences = new WeakMap();
 function serializeNumber(number) {
   return Number.isFinite(number)
@@ -159,9 +164,36 @@ function processReply(
   root,
   formFieldPrefix,
   temporaryReferences,
-  resolve,
-  reject
+  onResolve,
+  onReject,
+  signal
 ) {
+  function endReplyLifetime() {
+    null !== replyLifetimeController &&
+      replyLifetimeController.abort("The reply ended.");
+  }
+  function resolve(value) {
+    settled = !0;
+    endReplyLifetime();
+    onResolve(value);
+  }
+  function reject(error) {
+    settled = !0;
+    endReplyLifetime();
+    onReject(error);
+  }
+  function attachAbortSignal(abortSignal) {
+    abortSignal.aborted
+      ? abort()
+      : ((replyLifetimeController = new AbortController()),
+        abortSignal.addEventListener(
+          "abort",
+          function () {
+            abort();
+          },
+          { signal: replyLifetimeController.signal }
+        ));
+  }
   function serializeTypedArray(tag, typedArray) {
     typedArray = new Blob([
       new Uint8Array(
@@ -273,6 +305,8 @@ function processReply(
                 "$T"
               );
           }
+          if (void 0 !== temporaryReferences && modelRoot === value)
+            return (modelRoot = null), "$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."
           );
@@ -434,7 +468,7 @@ function processReply(
         return serializeAsyncIterable(value, key.call(value));
       key = getPrototypeOf(value);
       if (
-        key !== ObjectPrototype &&
+        key !== ObjectPrototype$1 &&
         (null === key || null !== getPrototypeOf(key))
       ) {
         if (void 0 === temporaryReferences)
@@ -513,21 +547,25 @@ function processReply(
     modelRoot = model;
     return JSON.stringify(model, resolveToJSON);
   }
+  function abort() {
+    endReplyLifetime();
+    0 < pendingParts &&
+      ((pendingParts = 0),
+      null === formData ? resolve(json) : resolve(formData));
+  }
   var nextPartId = 1,
     pendingParts = 0,
     formData = null,
     writtenObjects = new WeakMap(),
     modelRoot = root,
+    settled = !1,
+    replyLifetimeController = null,
     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));
-  };
+  void 0 === signal || settled || attachAbortSignal(signal);
 }
 var boundCache = new WeakMap();
 function encodeFormData(reference) {
@@ -702,37 +740,46 @@ function createServerReference$1(id, callServer, encodeFormAction) {
   registerBoundServerReference(action, id, null, encodeFormAction);
   return action;
 }
+var ObjectPrototype = Object.prototype,
+  ArrayPrototype = Array.prototype;
 function ReactPromise(status, value, reason) {
   this.status = status;
   this.value = value;
   this.reason = reason;
 }
 ReactPromise.prototype = Object.create(Promise.prototype);
-ReactPromise.prototype.then = function (resolve, reject) {
-  switch (this.status) {
-    case "resolved_model":
-      initializeModelChunk(this);
-      break;
-    case "resolved_module":
-      initializeModuleChunk(this);
-  }
-  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);
+Object.defineProperty(ReactPromise.prototype, "then", {
+  writable: !0,
+  enumerable: !0,
+  configurable: !0,
+  value: function (resolve, reject) {
+    switch (this.status) {
+      case "resolved_model":
+        initializeModelChunk(this);
+        break;
+      case "resolved_module":
+        initializeModuleChunk(this);
+    }
+    switch (this.status) {
+      case "fulfilled":
+        "function" === typeof resolve && resolve(this.value);
+        break;
+      case "pending":
+      case "pending_weak":
+      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);
+    }
   }
-};
+});
 function readChunk(chunk) {
   switch (chunk.status) {
     case "resolved_model":
@@ -745,6 +792,7 @@ function readChunk(chunk) {
     case "fulfilled":
       return chunk.value;
     case "pending":
+    case "pending_weak":
     case "blocked":
     case "halted":
       throw chunk;
@@ -752,20 +800,20 @@ function readChunk(chunk) {
       throw chunk.reason;
   }
 }
-function wakeChunk(listeners, 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(listener, value, chunk);
+      : fulfillReference(response, listener, value, chunk);
   }
 }
-function rejectChunk(listeners, error) {
+function rejectChunk(response, listeners, error) {
   for (var i = 0; i < listeners.length; i++) {
     var listener = listeners[i];
     "function" === typeof listener
       ? listener(error)
-      : rejectReference(listener, error);
+      : rejectReference(response, listener.handler, error);
   }
 }
 function resolveBlockedCycle(resolvedChunk, reference) {
@@ -789,10 +837,15 @@ function resolveBlockedCycle(resolvedChunk, reference) {
     }
   return null;
 }
-function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+function wakeChunkIfInitialized(
+  response,
+  chunk,
+  resolveListeners,
+  rejectListeners
+) {
   switch (chunk.status) {
     case "fulfilled":
-      wakeChunk(resolveListeners, chunk.value, chunk);
+      wakeChunk(response, resolveListeners, chunk.value, chunk);
       break;
     case "blocked":
       for (var i = 0; i < resolveListeners.length; i++) {
@@ -801,7 +854,7 @@ function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
           var cyclicHandler = resolveBlockedCycle(chunk, listener);
           if (null !== cyclicHandler)
             switch (
-              (fulfillReference(listener, cyclicHandler.value, chunk),
+              (fulfillReference(response, listener, cyclicHandler.value, chunk),
               resolveListeners.splice(i, 1),
               i--,
               null !== rejectListeners &&
@@ -810,19 +863,19 @@ function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
               chunk.status)
             ) {
               case "fulfilled":
-                wakeChunk(resolveListeners, chunk.value, chunk);
+                wakeChunk(response, resolveListeners, chunk.value, chunk);
                 return;
               case "rejected":
                 null !== rejectListeners &&
-                  rejectChunk(rejectListeners, chunk.reason);
+                  rejectChunk(response, rejectListeners, chunk.reason);
                 return;
             }
         }
       }
     case "pending":
       if (chunk.value)
-        for (i = 0; i < resolveListeners.length; i++)
-          chunk.value.push(resolveListeners[i]);
+        for (response = 0; response < resolveListeners.length; response++)
+          chunk.value.push(resolveListeners[response]);
       else chunk.value = resolveListeners;
       if (chunk.reason) {
         if (rejectListeners)
@@ -835,16 +888,22 @@ function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
       } else chunk.reason = rejectListeners;
       break;
     case "rejected":
-      rejectListeners && rejectChunk(rejectListeners, chunk.reason);
+      rejectListeners && rejectChunk(response, rejectListeners, chunk.reason);
   }
 }
 function triggerErrorOnChunk(response, chunk, error) {
-  "pending" !== chunk.status && "blocked" !== chunk.status
-    ? chunk.reason.error(error)
-    : ((response = chunk.reason),
-      (chunk.status = "rejected"),
-      (chunk.reason = error),
-      null !== response && rejectChunk(response, error));
+  if (
+    "pending" !== chunk.status &&
+    "pending_weak" !== chunk.status &&
+    "blocked" !== chunk.status
+  )
+    chunk.reason.error(error);
+  else {
+    var listeners = chunk.reason;
+    chunk.status = "rejected";
+    chunk.reason = error;
+    null !== listeners && rejectChunk(response, listeners, error);
+  }
 }
 function createResolvedIteratorResultChunk(response, value, done) {
   return new ReactPromise(
@@ -861,7 +920,8 @@ function resolveIteratorResultChunk(response, chunk, value, done) {
   );
 }
 function resolveModelChunk(response, chunk, value) {
-  if ("pending" !== chunk.status) chunk.reason.enqueueModel(value);
+  if ("pending" !== chunk.status && "pending_weak" !== chunk.status)
+    chunk.reason.enqueueModel(value);
   else {
     var resolveListeners = chunk.value,
       rejectListeners = chunk.reason;
@@ -870,19 +930,33 @@ function resolveModelChunk(response, chunk, value) {
     chunk.reason = response;
     null !== resolveListeners &&
       (initializeModelChunk(chunk),
-      wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
+      wakeChunkIfInitialized(
+        response,
+        chunk,
+        resolveListeners,
+        rejectListeners
+      ));
   }
 }
 function resolveModuleChunk(response, chunk, value) {
-  if ("pending" === chunk.status || "blocked" === chunk.status) {
-    response = chunk.value;
-    var rejectListeners = chunk.reason;
+  if (
+    "pending" === chunk.status ||
+    "pending_weak" === chunk.status ||
+    "blocked" === chunk.status
+  ) {
+    var resolveListeners = chunk.value,
+      rejectListeners = chunk.reason;
     chunk.status = "resolved_module";
     chunk.value = value;
     chunk.reason = null;
-    null !== response &&
+    null !== resolveListeners &&
       (initializeModuleChunk(chunk),
-      wakeChunkIfInitialized(chunk, response, rejectListeners));
+      wakeChunkIfInitialized(
+        response,
+        chunk,
+        resolveListeners,
+        rejectListeners
+      ));
   }
 }
 var initializingHandler = null;
@@ -895,29 +969,51 @@ function initializeModelChunk(chunk) {
   chunk.value = null;
   chunk.reason = null;
   try {
-    var value = JSON.parse(resolvedModel, response._fromJSON),
-      resolveListeners = chunk.value;
-    if (null !== resolveListeners)
+    var value = parseModel(response, resolvedModel);
+    resolvedModel = initializingHandler;
+    if (null !== resolvedModel) {
+      if (resolvedModel.errored) {
+        "blocked" === chunk.status &&
+          triggerErrorOnChunk(response, chunk, resolvedModel.reason);
+        return;
+      }
+      resolvedModel.value = value;
+      resolvedModel.chunk = chunk;
+    }
+    var listeners = chunk.value,
+      rejectListeners = chunk.reason;
+    chunk.value = null;
+    chunk.reason = null;
+    if (null !== listeners) {
       for (
-        chunk.value = null, chunk.reason = null, resolvedModel = 0;
-        resolvedModel < resolveListeners.length;
-        resolvedModel++
+        var cyclic = null, deferred = null, i = 0;
+        i < listeners.length;
+        i++
       ) {
-        var listener = resolveListeners[resolvedModel];
-        "function" === typeof listener
-          ? listener(value)
-          : fulfillReference(listener, value, chunk);
-      }
-    if (null !== initializingHandler) {
-      if (initializingHandler.errored) throw initializingHandler.reason;
-      if (0 < initializingHandler.deps) {
-        initializingHandler.value = value;
-        initializingHandler.chunk = chunk;
-        return;
+        var listener = listeners[i];
+        if (
+          "function" !== typeof listener &&
+          null !== resolveBlockedCycle(chunk, listener)
+        ) {
+          if (
+            (null === cyclic && (cyclic = []),
+            cyclic.push(listener),
+            null !== rejectListeners)
+          ) {
+            var rejectionIdx = rejectListeners.indexOf(listener);
+            -1 !== rejectionIdx && rejectListeners.splice(rejectionIdx, 1);
+          }
+        } else null === deferred && (deferred = []), deferred.push(listener);
       }
+      null !== deferred &&
+        ((chunk.value = deferred), (chunk.reason = rejectListeners));
+      if (null !== cyclic)
+        for (listeners = 0; listeners < cyclic.length; listeners++)
+          fulfillReference(response, cyclic[listeners], value, chunk);
     }
-    chunk.status = "fulfilled";
-    chunk.value = value;
+    "blocked" !== chunk.status ||
+      (null !== resolvedModel && 0 < resolvedModel.deps) ||
+      initializeBlockedChunk(response, chunk, value, null);
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   } finally {
@@ -929,6 +1025,7 @@ function initializeModuleChunk(chunk) {
     var value = requireModule(chunk.value);
     chunk.status = "fulfilled";
     chunk.value = value;
+    chunk.reason = null;
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   }
@@ -952,14 +1049,31 @@ function getChunk(response, id) {
     chunk = chunks.get(id);
   chunk ||
     ((chunk = response._closed
-      ? new ReactPromise("rejected", null, response._closedReason)
+      ? response._allowPartialStream
+        ? new ReactPromise("halted", null, null)
+        : new ReactPromise("rejected", null, response._closedReason)
       : new ReactPromise("pending", null, null)),
     chunks.set(id, chunk));
   return chunk;
 }
-function fulfillReference(reference, value) {
-  var response = reference.response,
-    handler = reference.handler,
+function initializeBlockedChunk(response, chunk, value, reason) {
+  var resolveListeners = chunk.value;
+  chunk.status = "fulfilled";
+  chunk.value = value;
+  chunk.reason = reason;
+  null !== resolveListeners &&
+    wakeChunk(response, resolveListeners, value, chunk);
+}
+function initializeChunkIfUnblocked(response, handler) {
+  if (0 === handler.deps && !handler.errored) {
+    var chunk = handler.chunk;
+    null !== chunk &&
+      "blocked" === chunk.status &&
+      initializeBlockedChunk(response, chunk, handler.value, handler.reason);
+  }
+}
+function fulfillReference(response, reference, value) {
+  var handler = reference.handler,
     parentObject = reference.parentObject,
     key = reference.key,
     map = reference.map,
@@ -997,6 +1111,7 @@ function fulfillReference(reference, value) {
                 continue;
               }
             case "pending":
+            case "pending_weak":
               path.splice(0, i - 1);
               null === referencedChunk.value
                 ? (referencedChunk.value = [reference])
@@ -1008,7 +1123,11 @@ function fulfillReference(reference, value) {
             case "halted":
               return;
             default:
-              rejectReference(reference, referencedChunk.reason);
+              rejectReference(
+                response,
+                reference.handler,
+                referencedChunk.reason
+              );
               return;
           }
         }
@@ -1029,19 +1148,19 @@ function fulfillReference(reference, value) {
       value.$$typeof === REACT_LAZY_TYPE;
 
     ) {
-      var referencedChunk$44 = value._payload;
-      if (referencedChunk$44 === handler.chunk) value = handler.value;
+      var referencedChunk$45 = value._payload;
+      if (referencedChunk$45 === handler.chunk) value = handler.value;
       else {
-        switch (referencedChunk$44.status) {
+        switch (referencedChunk$45.status) {
           case "resolved_model":
-            initializeModelChunk(referencedChunk$44);
+            initializeModelChunk(referencedChunk$45);
             break;
           case "resolved_module":
-            initializeModuleChunk(referencedChunk$44);
+            initializeModuleChunk(referencedChunk$45);
         }
-        switch (referencedChunk$44.status) {
+        switch (referencedChunk$45.status) {
           case "fulfilled":
-            value = referencedChunk$44.value;
+            value = referencedChunk$45.value;
             continue;
         }
         break;
@@ -1063,23 +1182,13 @@ function fulfillReference(reference, value) {
       }
     }
   } catch (error) {
-    rejectReference(reference, 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(value, handler.value, reference)));
-}
-function rejectReference(reference, error) {
-  var handler = reference.handler;
-  reference = reference.response;
+  initializeChunkIfUnblocked(response, handler);
+}
+function rejectReference(response, handler, error) {
   handler.errored ||
     ((handler.errored = !0),
     (handler.value = null),
@@ -1087,7 +1196,7 @@ function rejectReference(reference, error) {
     (handler = handler.chunk),
     null !== handler &&
       "blocked" === handler.status &&
-      triggerErrorOnChunk(reference, handler, error));
+      triggerErrorOnChunk(response, handler, error));
 }
 function waitForReference(
   referencedChunk,
@@ -1097,21 +1206,19 @@ function waitForReference(
   map,
   path
 ) {
-  if (initializingHandler) {
-    var handler = initializingHandler;
-    handler.deps++;
-  } else
-    handler = initializingHandler = {
-      parent: null,
-      chunk: null,
-      value: null,
-      reason: null,
-      deps: 1,
-      errored: !1
-    };
+  initializingHandler
+    ? ((response = initializingHandler), response.deps++)
+    : (response = initializingHandler =
+        {
+          parent: null,
+          chunk: null,
+          value: null,
+          reason: null,
+          deps: 1,
+          errored: !1
+        });
   parentObject = {
-    response: response,
-    handler: handler,
+    handler: response,
     parentObject: parentObject,
     key: key,
     map: map,
@@ -1190,34 +1297,28 @@ function loadServerReference(response, metaData, parentObject, key) {
             boundArgs.props = 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(boundArgs, handler.value, resolvedValue)));
+      initializeChunkIfUnblocked(response, handler);
     },
     function (error) {
       if (!handler.errored) {
-        handler.errored = !0;
-        handler.value = null;
-        handler.reason = error;
-        var chunk = handler.chunk;
-        null !== chunk &&
-          "blocked" === chunk.status &&
-          triggerErrorOnChunk(response, chunk, error);
+        var erroredHandler = handler;
+        erroredHandler.errored = !0;
+        erroredHandler.value = null;
+        erroredHandler.reason = error;
+        erroredHandler = handler.chunk;
+        null !== erroredHandler &&
+          "blocked" === erroredHandler.status &&
+          triggerErrorOnChunk(response, erroredHandler, error);
       }
     }
   );
   return null;
 }
+var EMPTY_REFERENCE_PATH = [];
 function getOutlinedModel(response, reference, parentObject, key, map) {
-  reference = reference.split(":");
-  var id = parseInt(reference[0], 16);
+  var id = parseInt(reference, 16);
+  reference =
+    -1 === reference.indexOf(":") ? EMPTY_REFERENCE_PATH : reference.split(":");
   id = getChunk(response, id);
   switch (id.status) {
     case "resolved_model":
@@ -1251,6 +1352,7 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
               break;
             case "blocked":
             case "pending":
+            case "pending_weak":
               return waitForReference(
                 id,
                 parentObject,
@@ -1276,9 +1378,10 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
             default:
               return (
                 initializingHandler
-                  ? ((initializingHandler.errored = !0),
-                    (initializingHandler.value = null),
-                    (initializingHandler.reason = id.reason))
+                  ? ((response = initializingHandler),
+                    (response.errored = !0),
+                    (response.value = null),
+                    (response.reason = id.reason))
                   : (initializingHandler = {
                       parent: null,
                       chunk: null,
@@ -1291,7 +1394,16 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
               );
           }
         }
-        id = id[reference[i]];
+        var name = reference[i];
+        if (
+          "object" !== typeof id ||
+          null === id ||
+          (getPrototypeOf(id) !== ObjectPrototype &&
+            getPrototypeOf(id) !== ArrayPrototype) ||
+          !hasOwnProperty.call(id, name)
+        )
+          throw Error("Invalid reference.");
+        id = id[name];
       }
       for (
         ;
@@ -1317,6 +1429,7 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
       }
       return map(response, id, parentObject, key);
     case "pending":
+    case "pending_weak":
     case "blocked":
       return waitForReference(id, parentObject, key, response, map, reference);
     case "halted":
@@ -1336,9 +1449,10 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
     default:
       return (
         initializingHandler
-          ? ((initializingHandler.errored = !0),
-            (initializingHandler.value = null),
-            (initializingHandler.reason = id.reason))
+          ? ((response = initializingHandler),
+            (response.errored = !0),
+            (response.value = null),
+            (response.reason = id.reason))
           : (initializingHandler = {
               parent: null,
               chunk: null,
@@ -1402,6 +1516,8 @@ function parseModelString(response, parentObject, key, value) {
           (parentObject = parseInt(value.slice(2), 16)),
           getChunk(response, parentObject)
         );
+      case "w":
+        return;
       case "S":
         return Symbol.for(value.slice(2));
       case "h":
@@ -1483,7 +1599,8 @@ function ResponseInstance(
   callServer,
   encodeFormAction,
   nonce,
-  temporaryReferences
+  temporaryReferences,
+  allowPartialStream
 ) {
   var chunks = new Map();
   this._bundlerConfig = bundlerConfig;
@@ -1494,11 +1611,10 @@ function ResponseInstance(
   this._nonce = nonce;
   this._chunks = chunks;
   this._stringDecoder = new TextDecoder();
-  this._fromJSON = null;
   this._closed = !1;
   this._closedReason = null;
+  this._allowPartialStream = allowPartialStream;
   this._tempRefs = temporaryReferences;
-  this._fromJSON = createFromJSONCallback(this);
 }
 function resolveBuffer(response, id, buffer) {
   response = response._chunks;
@@ -1510,12 +1626,25 @@ function resolveBuffer(response, id, buffer) {
 }
 function resolveModule(response, id, model) {
   var chunks = response._chunks,
-    chunk = chunks.get(id);
-  model = JSON.parse(model, response._fromJSON);
-  var clientReference = resolveClientReference(response._bundlerConfig, model);
+    chunk = chunks.get(id),
+    prevHandler = initializingHandler;
+  initializingHandler = null;
+  try {
+    var clientReferenceMetadata = parseModel(response, model);
+    if (null !== initializingHandler)
+      throw Error(
+        "A client reference was blocked on a row that has not been received yet. This is a bug in React."
+      );
+  } finally {
+    initializingHandler = prevHandler;
+  }
+  var clientReference = resolveClientReference(
+    response._bundlerConfig,
+    clientReferenceMetadata
+  );
   prepareDestinationWithChunks(
     response._moduleLoading,
-    model[1],
+    clientReferenceMetadata[1],
     response._nonce
   );
   if ((model = preloadModule(clientReference))) {
@@ -1540,17 +1669,17 @@ function resolveModule(response, id, model) {
         chunks.set(id, chunk));
 }
 function resolveStream(response, id, stream, controller) {
-  response = response._chunks;
-  var chunk = response.get(id);
+  var chunks = response._chunks,
+    chunk = chunks.get(id);
   chunk
     ? "pending" === chunk.status &&
       ((id = chunk.value),
       (chunk.status = "fulfilled"),
       (chunk.value = stream),
       (chunk.reason = controller),
-      null !== id && wakeChunk(id, chunk.value, chunk))
-    : ((stream = new ReactPromise("fulfilled", stream, controller)),
-      response.set(id, stream));
+      null !== id && wakeChunk(response, id, chunk.value, chunk))
+    : ((response = new ReactPromise("fulfilled", stream, controller)),
+      chunks.set(id, response));
 }
 function startReadableStream(response, id, type) {
   var controller = null,
@@ -1587,8 +1716,8 @@ function startReadableStream(response, id, type) {
             (previousBlockedChunk = chunk));
       } else {
         chunk = previousBlockedChunk;
-        var chunk$55 = new ReactPromise("pending", null, null);
-        chunk$55.then(
+        var chunk$57 = new ReactPromise("pending", null, null);
+        chunk$57.then(
           function (v) {
             return controller.enqueue(v);
           },
@@ -1596,10 +1725,10 @@ function startReadableStream(response, id, type) {
             return controller.error(e);
           }
         );
-        previousBlockedChunk = chunk$55;
+        previousBlockedChunk = chunk$57;
         chunk.then(function () {
-          previousBlockedChunk === chunk$55 && (previousBlockedChunk = null);
-          resolveModelChunk(response, chunk$55, json);
+          previousBlockedChunk === chunk$57 && (previousBlockedChunk = null);
+          resolveModelChunk(response, chunk$57, json);
         });
       }
     },
@@ -1680,7 +1809,12 @@ function startAsyncIterable(response, id, iterator) {
           chunk.value = { done: !1, value: value };
           chunk.reason = null;
           null !== resolveListeners &&
-            wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+            wakeChunkIfInitialized(
+              response,
+              chunk,
+              resolveListeners,
+              rejectListeners
+            );
         }
         nextWriteIndex++;
       },
@@ -1755,8 +1889,8 @@ 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 i$56 = (i = 0); i$56 < l; i$56++) {
-    var chunk = buffer[i$56];
+  for (var i$58 = (i = 0); i$58 < l; i$58++) {
+    var chunk = buffer[i$58];
     byteLength.set(chunk, i);
     i += chunk.byteLength;
   }
@@ -1839,7 +1973,7 @@ function processFullBinaryRow(response, streamState, id, tag, buffer, chunk) {
     case 72:
       id = buffer[0];
       buffer = buffer.slice(1);
-      response = JSON.parse(buffer, response._fromJSON);
+      response = parseModel(response, buffer);
       buffer = ReactDOMSharedInternals.d;
       switch (id) {
         case "D":
@@ -1932,45 +2066,70 @@ function processFullBinaryRow(response, streamState, id, tag, buffer, chunk) {
             tag.set(id, response));
   }
 }
-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) {
-          if (
-            ((key = {
+function parseModel(response, json) {
+  json = JSON.parse(json);
+  return reviveModel(response, json, { "": json }, "");
+}
+function reviveModel(response, value, parentObject, key) {
+  if ("string" === typeof value)
+    return "$" === value[0]
+      ? parseModelString(response, parentObject, key, value)
+      : value;
+  if ("object" !== typeof value || null === value) return value;
+  if (isArrayImpl(value)) {
+    for (var i = 0; i < value.length; i++)
+      value[i] = reviveModel(response, value[i], value, "" + i);
+    return value[0] === REACT_ELEMENT_TYPE
+      ? (value[0] === REACT_ELEMENT_TYPE
+          ? ((response = {
               $$typeof: REACT_ELEMENT_TYPE,
               type: value[1],
               key: value[2],
               ref: null,
               props: value[3]
             }),
-            null !== initializingHandler)
-          )
-            if (
+            null !== initializingHandler &&
               ((value = initializingHandler),
               (initializingHandler = value.parent),
-              value.errored)
-            )
-              (key = new ReactPromise("rejected", null, value.reason)),
-                (key = createLazyChunkWrapper(key));
-            else if (0 < value.deps) {
-              var blockedChunk = new ReactPromise("blocked", null, null);
-              value.value = key;
-              value.chunk = blockedChunk;
-              key = createLazyChunkWrapper(blockedChunk);
-            }
-        } else key = value;
-        return key;
-      }
-      return value;
-    }
-  };
+              value.errored
+                ? ((response = new ReactPromise(
+                    "rejected",
+                    null,
+                    value.reason
+                  )),
+                  (response = createLazyChunkWrapper(response)))
+                : 0 < value.deps &&
+                  ((i = new ReactPromise("blocked", null, null)),
+                  (value.value = response),
+                  (value.chunk = i),
+                  (response = createLazyChunkWrapper(i)))))
+          : (response = value),
+        response)
+      : value;
+  }
+  for (i in value)
+    hasOwnProperty.call(value, i) &&
+      ("__proto__" === i
+        ? delete value[i]
+        : ((parentObject = reviveModel(response, value[i], value, i)),
+          void 0 !== parentObject
+            ? (value[i] = parentObject)
+            : delete value[i]));
+  return value;
 }
 function close(weakResponse) {
-  reportGlobalError(weakResponse, Error("Connection closed."));
+  weakResponse._allowPartialStream
+    ? ((weakResponse._closed = !0),
+      weakResponse._chunks.forEach(function (chunk) {
+        "pending" === chunk.status
+          ? ((chunk.status = "halted"),
+            (chunk.value = null),
+            (chunk.reason = null))
+          : "fulfilled" === chunk.status &&
+            null !== chunk.reason &&
+            chunk.reason.close('"$undefined"');
+      }))
+    : reportGlobalError(weakResponse, Error("Connection closed."));
 }
 function noServerCall() {
   throw Error(
@@ -1987,7 +2146,10 @@ function createResponseFromOptions(options) {
     "string" === typeof options.nonce ? options.nonce : void 0,
     options && options.temporaryReferences
       ? options.temporaryReferences
-      : void 0
+      : void 0,
+    options && options.unstable_allowPartialStream
+      ? options.unstable_allowPartialStream
+      : !1
   );
 }
 function startReadingFromStream(response, stream, onDone) {
@@ -2020,6 +2182,7 @@ function startReadingFromStream(response, stream, onDone) {
           65 === rowState ||
           79 === rowState ||
           111 === rowState ||
+          98 === rowState ||
           85 === rowState ||
           83 === rowState ||
           115 === rowState ||
@@ -2055,22 +2218,30 @@ function startReadingFromStream(response, stream, onDone) {
       var offset = value.byteOffset + i;
       if (-1 < lastIdx)
         (rowLength = new Uint8Array(value.buffer, offset, lastIdx - i)),
-          processFullBinaryRow(
-            response,
-            streamState,
-            _ref,
-            rowTag,
-            buffer,
-            rowLength
-          ),
+          98 === rowTag
+            ? resolveBuffer(
+                response,
+                _ref,
+                lastIdx === chunkLength ? rowLength : rowLength.slice()
+              )
+            : processFullBinaryRow(
+                response,
+                streamState,
+                _ref,
+                rowTag,
+                buffer,
+                rowLength
+              ),
           (i = lastIdx),
           3 === rowState && i++,
           (rowLength = _ref = rowTag = rowState = 0),
           (buffer.length = 0);
       else {
         value = new Uint8Array(value.buffer, offset, value.byteLength - i);
-        buffer.push(value);
-        rowLength -= value.byteLength;
+        98 === rowTag
+          ? ((rowLength -= value.byteLength),
+            resolveBuffer(response, _ref, value))
+          : (buffer.push(value), (rowLength -= value.byteLength));
         break;
       }
     }
@@ -2118,26 +2289,16 @@ exports.createTemporaryReferenceSet = function () {
 };
 exports.encodeReply = function (value, options) {
   return new Promise(function (resolve, reject) {
-    var abort = processReply(
+    processReply(
       value,
       "",
       options && options.temporaryReferences
         ? options.temporaryReferences
         : void 0,
       resolve,
-      reject
+      reject,
+      options ? options.signal : void 0
     );
-    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, encodeFormAction) {