@vitejs/plugin-rsc 0.4.33 → 0.5.0

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

@@ -212,11 +212,11 @@ function processReply(
         0 === pendingParts && resolve(data);
       } else
         try {
-          var partJSON$22 = JSON.stringify(entry.value, resolveToJSON);
-          data.append(formFieldPrefix + streamId, partJSON$22);
+          var partJSON$21 = JSON.stringify(entry.value, resolveToJSON);
+          data.append(formFieldPrefix + streamId, partJSON$21);
           iterator.next().then(progress, reject);
-        } catch (x$23) {
-          reject(x$23);
+        } catch (x$22) {
+          reject(x$22);
         }
     }
     null === formData && (formData = new FormData());
@@ -261,20 +261,20 @@ function processReply(
               "function" === typeof x.then
             ) {
               pendingParts++;
-              var lazyId$24 = nextPartId++;
+              var lazyId$23 = nextPartId++;
               parentReference = function () {
                 try {
-                  var partJSON$25 = serializeModel(value, lazyId$24),
-                    data$26 = formData;
-                  data$26.append(formFieldPrefix + lazyId$24, partJSON$25);
+                  var partJSON$24 = serializeModel(value, lazyId$23),
+                    data$25 = formData;
+                  data$25.append(formFieldPrefix + lazyId$23, partJSON$24);
                   pendingParts--;
-                  0 === pendingParts && resolve(data$26);
+                  0 === pendingParts && resolve(data$25);
                 } catch (reason) {
                   reject(reason);
                 }
               };
               x.then(parentReference, parentReference);
-              return "$" + lazyId$24.toString(16);
+              return "$" + lazyId$23.toString(16);
             }
             reject(x);
             return null;
@@ -288,9 +288,9 @@ function processReply(
         var promiseId = nextPartId++;
         value.then(function (partValue) {
           try {
-            var partJSON$28 = serializeModel(partValue, promiseId);
+            var partJSON$27 = serializeModel(partValue, promiseId);
             partValue = formData;
-            partValue.append(formFieldPrefix + promiseId, partJSON$28);
+            partValue.append(formFieldPrefix + promiseId, partJSON$27);
             pendingParts--;
             0 === pendingParts && resolve(partValue);
           } catch (reason) {
@@ -314,11 +314,11 @@ function processReply(
       if (isArrayImpl(value)) return value;
       if (value instanceof FormData) {
         null === formData && (formData = new FormData());
-        var data$32 = formData;
+        var data$31 = formData;
         key = nextPartId++;
         var prefix = formFieldPrefix + key + "_";
         value.forEach(function (originalValue, originalKey) {
-          data$32.append(prefix + originalKey, originalValue);
+          data$31.append(prefix + originalKey, originalValue);
         });
         return "$K" + key.toString(16);
       }
@@ -657,11 +657,10 @@ function createServerReference$1(id, callServer, encodeFormAction) {
   registerBoundServerReference(action, id, null, encodeFormAction);
   return action;
 }
-function ReactPromise(status, value, reason, response) {
+function ReactPromise(status, value, reason) {
   this.status = status;
   this.value = value;
   this.reason = reason;
-  this._response = response;
 }
 ReactPromise.prototype = Object.create(Promise.prototype);
 ReactPromise.prototype.then = function (resolve, reject) {
@@ -674,17 +673,19 @@ ReactPromise.prototype.then = function (resolve, reject) {
   }
   switch (this.status) {
     case "fulfilled":
-      resolve(this.value);
+      "function" === typeof resolve && resolve(this.value);
       break;
     case "pending":
     case "blocked":
-      resolve &&
+      "function" === typeof resolve &&
         (null === this.value && (this.value = []), this.value.push(resolve));
-      reject &&
+      "function" === typeof reject &&
         (null === this.reason && (this.reason = []), this.reason.push(reject));
       break;
+    case "halted":
+      break;
     default:
-      reject && reject(this.reason);
+      "function" === typeof reject && reject(this.reason);
   }
 };
 function readChunk(chunk) {
@@ -700,26 +701,71 @@ function readChunk(chunk) {
       return chunk.value;
     case "pending":
     case "blocked":
+    case "halted":
       throw chunk;
     default:
       throw chunk.reason;
   }
 }
-function createPendingChunk(response) {
-  return new ReactPromise("pending", null, null, response);
-}
 function wakeChunk(listeners, value) {
-  for (var i = 0; i < listeners.length; i++) (0, listeners[i])(value);
+  for (var i = 0; i < listeners.length; i++) {
+    var listener = listeners[i];
+    "function" === typeof listener
+      ? listener(value)
+      : fulfillReference(listener, value);
+  }
+}
+function rejectChunk(listeners, error) {
+  for (var i = 0; i < listeners.length; i++) {
+    var listener = listeners[i];
+    "function" === typeof listener
+      ? listener(error)
+      : rejectReference(listener, 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(chunk, resolveListeners, rejectListeners) {
   switch (chunk.status) {
     case "fulfilled":
       wakeChunk(resolveListeners, chunk.value);
       break;
-    case "pending":
     case "blocked":
+      for (var i = 0; i < resolveListeners.length; i++) {
+        var listener = resolveListeners[i];
+        if ("function" !== typeof listener) {
+          var cyclicHandler = resolveBlockedCycle(chunk, listener);
+          null !== cyclicHandler &&
+            (fulfillReference(listener, cyclicHandler.value),
+            resolveListeners.splice(i, 1),
+            i--,
+            null !== rejectListeners &&
+              ((listener = rejectListeners.indexOf(listener)),
+              -1 !== listener && rejectListeners.splice(listener, 1)));
+        }
+      }
+    case "pending":
       if (chunk.value)
-        for (var i = 0; i < resolveListeners.length; i++)
+        for (i = 0; i < resolveListeners.length; i++)
           chunk.value.push(resolveListeners[i]);
       else chunk.value = resolveListeners;
       if (chunk.reason) {
@@ -733,73 +779,80 @@ function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
       } else chunk.reason = rejectListeners;
       break;
     case "rejected":
-      rejectListeners && wakeChunk(rejectListeners, chunk.reason);
+      rejectListeners && rejectChunk(rejectListeners, chunk.reason);
   }
 }
-function triggerErrorOnChunk(chunk, error) {
-  if ("pending" !== chunk.status && "blocked" !== chunk.status)
-    chunk.reason.error(error);
-  else {
-    var listeners = chunk.reason;
-    chunk.status = "rejected";
-    chunk.reason = error;
-    null !== listeners && wakeChunk(listeners, error);
-  }
+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));
 }
 function createResolvedIteratorResultChunk(response, value, done) {
   return new ReactPromise(
     "resolved_model",
     (done ? '{"done":true,"value":' : '{"done":false,"value":') + value + "}",
-    null,
     response
   );
 }
-function resolveIteratorResultChunk(chunk, value, done) {
+function resolveIteratorResultChunk(response, chunk, value, done) {
   resolveModelChunk(
+    response,
     chunk,
     (done ? '{"done":true,"value":' : '{"done":false,"value":') + value + "}"
   );
 }
-function resolveModelChunk(chunk, value) {
+function resolveModelChunk(response, chunk, value) {
   if ("pending" !== chunk.status) chunk.reason.enqueueModel(value);
   else {
     var resolveListeners = chunk.value,
       rejectListeners = chunk.reason;
     chunk.status = "resolved_model";
     chunk.value = value;
+    chunk.reason = response;
     null !== resolveListeners &&
       (initializeModelChunk(chunk),
       wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
   }
 }
-function resolveModuleChunk(chunk, value) {
+function resolveModuleChunk(response, chunk, value) {
   if ("pending" === chunk.status || "blocked" === chunk.status) {
-    var resolveListeners = chunk.value,
-      rejectListeners = chunk.reason;
+    response = chunk.value;
+    var rejectListeners = chunk.reason;
     chunk.status = "resolved_module";
     chunk.value = value;
-    null !== resolveListeners &&
+    null !== response &&
       (initializeModuleChunk(chunk),
-      wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
+      wakeChunkIfInitialized(chunk, response, rejectListeners));
   }
 }
 var initializingHandler = null;
 function initializeModelChunk(chunk) {
   var prevHandler = initializingHandler;
   initializingHandler = null;
-  var resolvedModel = chunk.value;
+  var resolvedModel = chunk.value,
+    response = chunk.reason;
   chunk.status = "blocked";
   chunk.value = null;
   chunk.reason = null;
   try {
-    var value = JSON.parse(resolvedModel, chunk._response._fromJSON),
+    var value = JSON.parse(resolvedModel, response._fromJSON),
       resolveListeners = chunk.value;
-    null !== resolveListeners &&
-      ((chunk.value = null),
-      (chunk.reason = null),
-      wakeChunk(resolveListeners, 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(listener, value, chunk);
+      }
     if (null !== initializingHandler) {
-      if (initializingHandler.errored) throw initializingHandler.value;
+      if (initializingHandler.errored) throw initializingHandler.reason;
       if (0 < initializingHandler.deps) {
         initializingHandler.value = value;
         initializingHandler.chunk = chunk;
@@ -823,11 +876,12 @@ function initializeModuleChunk(chunk) {
     (chunk.status = "rejected"), (chunk.reason = error);
   }
 }
-function reportGlobalError(response, error) {
-  response._closed = !0;
-  response._closedReason = error;
-  response._chunks.forEach(function (chunk) {
-    "pending" === chunk.status && triggerErrorOnChunk(chunk, error);
+function reportGlobalError(weakResponse, error) {
+  weakResponse._closed = !0;
+  weakResponse._closedReason = error;
+  weakResponse._chunks.forEach(function (chunk) {
+    "pending" === chunk.status &&
+      triggerErrorOnChunk(weakResponse, chunk, error);
   });
 }
 function createLazyChunkWrapper(chunk) {
@@ -838,11 +892,128 @@ function getChunk(response, id) {
     chunk = chunks.get(id);
   chunk ||
     ((chunk = response._closed
-      ? new ReactPromise("rejected", null, response._closedReason, response)
-      : createPendingChunk(response)),
+      ? new ReactPromise("rejected", null, response._closedReason)
+      : new ReactPromise("pending", null, null)),
     chunks.set(id, chunk));
   return chunk;
 }
+function fulfillReference(reference, value) {
+  for (
+    var response = reference.response,
+      handler = reference.handler,
+      parentObject = reference.parentObject,
+      key = reference.key,
+      map = reference.map,
+      path = reference.path,
+      i = 1;
+    i < path.length;
+    i++
+  ) {
+    for (
+      ;
+      "object" === typeof value &&
+      null !== value &&
+      value.$$typeof === REACT_LAZY_TYPE;
+
+    )
+      if (((value = value._payload), value === handler.chunk))
+        value = handler.value;
+      else {
+        switch (value.status) {
+          case "resolved_model":
+            initializeModelChunk(value);
+            break;
+          case "resolved_module":
+            initializeModuleChunk(value);
+        }
+        switch (value.status) {
+          case "fulfilled":
+            value = value.value;
+            continue;
+          case "blocked":
+            var cyclicHandler = resolveBlockedCycle(value, reference);
+            if (null !== cyclicHandler) {
+              value = cyclicHandler.value;
+              continue;
+            }
+          case "pending":
+            path.splice(0, i - 1);
+            null === value.value
+              ? (value.value = [reference])
+              : value.value.push(reference);
+            null === value.reason
+              ? (value.reason = [reference])
+              : value.reason.push(reference);
+            return;
+          case "halted":
+            return;
+          default:
+            rejectReference(reference, value.reason);
+            return;
+        }
+      }
+    value = value[path[i]];
+  }
+  for (
+    ;
+    "object" === typeof value &&
+    null !== value &&
+    value.$$typeof === REACT_LAZY_TYPE;
+
+  )
+    if (((reference = value._payload), reference === handler.chunk))
+      value = handler.value;
+    else {
+      switch (reference.status) {
+        case "resolved_model":
+          initializeModelChunk(reference);
+          break;
+        case "resolved_module":
+          initializeModuleChunk(reference);
+      }
+      switch (reference.status) {
+        case "fulfilled":
+          value = reference.value;
+          continue;
+      }
+      break;
+    }
+  response = map(response, value, parentObject, key);
+  parentObject[key] = response;
+  "" === key && null === handler.value && (handler.value = response);
+  if (
+    parentObject[0] === REACT_ELEMENT_TYPE &&
+    "object" === typeof handler.value &&
+    null !== handler.value &&
+    handler.value.$$typeof === REACT_ELEMENT_TYPE
+  )
+    switch (((parentObject = handler.value), key)) {
+      case "3":
+        parentObject.props = response;
+    }
+  handler.deps--;
+  0 === handler.deps &&
+    ((key = handler.chunk),
+    null !== key &&
+      "blocked" === key.status &&
+      ((parentObject = key.value),
+      (key.status = "fulfilled"),
+      (key.value = handler.value),
+      (key.reason = handler.reason),
+      null !== parentObject && wakeChunk(parentObject, handler.value)));
+}
+function rejectReference(reference, error) {
+  var handler = reference.handler;
+  reference = reference.response;
+  handler.errored ||
+    ((handler.errored = !0),
+    (handler.value = null),
+    (handler.reason = error),
+    (handler = handler.chunk),
+    null !== handler &&
+      "blocked" === handler.status &&
+      triggerErrorOnChunk(reference, handler, error));
+}
 function waitForReference(
   referencedChunk,
   parentObject,
@@ -851,52 +1022,6 @@ function waitForReference(
   map,
   path
 ) {
-  function fulfill(value) {
-    for (var i = 1; i < path.length; i++) {
-      for (; value.$$typeof === REACT_LAZY_TYPE; )
-        if (((value = value._payload), value === handler.chunk))
-          value = handler.value;
-        else if ("fulfilled" === value.status) value = value.value;
-        else {
-          path.splice(0, i - 1);
-          value.then(fulfill, reject);
-          return;
-        }
-      value = value[path[i]];
-    }
-    i = map(response, value, parentObject, key);
-    parentObject[key] = i;
-    "" === key && null === handler.value && (handler.value = i);
-    if (
-      parentObject[0] === REACT_ELEMENT_TYPE &&
-      "object" === typeof handler.value &&
-      null !== handler.value &&
-      handler.value.$$typeof === REACT_ELEMENT_TYPE
-    )
-      switch (((value = handler.value), key)) {
-        case "3":
-          value.props = i;
-      }
-    handler.deps--;
-    0 === handler.deps &&
-      ((i = handler.chunk),
-      null !== i &&
-        "blocked" === i.status &&
-        ((value = i.value),
-        (i.status = "fulfilled"),
-        (i.value = handler.value),
-        null !== value && wakeChunk(value, handler.value)));
-  }
-  function reject(error) {
-    if (!handler.errored) {
-      handler.errored = !0;
-      handler.value = error;
-      var chunk = handler.chunk;
-      null !== chunk &&
-        "blocked" === chunk.status &&
-        triggerErrorOnChunk(chunk, error);
-    }
-  }
   if (initializingHandler) {
     var handler = initializingHandler;
     handler.deps++;
@@ -905,10 +1030,24 @@ function waitForReference(
       parent: null,
       chunk: null,
       value: null,
+      reason: null,
       deps: 1,
       errored: !1
     };
-  referencedChunk.then(fulfill, reject);
+  parentObject = {
+    response: response,
+    handler: handler,
+    parentObject: parentObject,
+    key: key,
+    map: map,
+    path: path
+  };
+  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) {
@@ -945,6 +1084,7 @@ function loadServerReference(response, metaData, parentObject, key) {
       parent: null,
       chunk: null,
       value: null,
+      reason: null,
       deps: 1,
       errored: !1
     };
@@ -987,11 +1127,12 @@ function loadServerReference(response, metaData, parentObject, key) {
     function (error) {
       if (!handler.errored) {
         handler.errored = !0;
-        handler.value = error;
+        handler.value = null;
+        handler.reason = error;
         var chunk = handler.chunk;
         null !== chunk &&
           "blocked" === chunk.status &&
-          triggerErrorOnChunk(chunk, error);
+          triggerErrorOnChunk(response, chunk, error);
       }
     }
   );
@@ -1010,35 +1151,122 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
   }
   switch (id.status) {
     case "fulfilled":
-      var value = id.value;
-      for (id = 1; id < reference.length; id++) {
-        for (; value.$$typeof === REACT_LAZY_TYPE; )
-          if (((value = value._payload), "fulfilled" === value.status))
-            value = value.value;
-          else
-            return waitForReference(
-              value,
-              parentObject,
-              key,
-              response,
-              map,
-              reference.slice(id - 1)
-            );
-        value = value[reference[id]];
+      id = id.value;
+      for (var i = 1; i < reference.length; i++) {
+        for (
+          ;
+          "object" === typeof id &&
+          null !== id &&
+          id.$$typeof === REACT_LAZY_TYPE;
+
+        ) {
+          id = id._payload;
+          switch (id.status) {
+            case "resolved_model":
+              initializeModelChunk(id);
+              break;
+            case "resolved_module":
+              initializeModuleChunk(id);
+          }
+          switch (id.status) {
+            case "fulfilled":
+              id = id.value;
+              break;
+            case "blocked":
+            case "pending":
+              return waitForReference(
+                id,
+                parentObject,
+                key,
+                response,
+                map,
+                reference.slice(i - 1)
+              );
+            case "halted":
+              return (
+                initializingHandler
+                  ? ((response = initializingHandler), response.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 = id.reason))
+                  : (initializingHandler = {
+                      parent: null,
+                      chunk: null,
+                      value: null,
+                      reason: id.reason,
+                      deps: 0,
+                      errored: !0
+                    }),
+                null
+              );
+          }
+        }
+        id = id[reference[i]];
       }
-      return map(response, value, parentObject, key);
+      for (
+        ;
+        "object" === typeof id &&
+        null !== id &&
+        id.$$typeof === REACT_LAZY_TYPE;
+
+      ) {
+        reference = id._payload;
+        switch (reference.status) {
+          case "resolved_model":
+            initializeModelChunk(reference);
+            break;
+          case "resolved_module":
+            initializeModuleChunk(reference);
+        }
+        switch (reference.status) {
+          case "fulfilled":
+            id = reference.value;
+            continue;
+        }
+        break;
+      }
+      return map(response, id, parentObject, key);
     case "pending":
     case "blocked":
       return waitForReference(id, parentObject, key, response, map, reference);
+    case "halted":
+      return (
+        initializingHandler
+          ? ((response = initializingHandler), response.deps++)
+          : (initializingHandler = {
+              parent: null,
+              chunk: null,
+              value: null,
+              reason: null,
+              deps: 1,
+              errored: !1
+            }),
+        null
+      );
     default:
       return (
         initializingHandler
           ? ((initializingHandler.errored = !0),
-            (initializingHandler.value = id.reason))
+            (initializingHandler.value = null),
+            (initializingHandler.reason = id.reason))
           : (initializingHandler = {
               parent: null,
               chunk: null,
-              value: id.reason,
+              value: null,
+              reason: id.reason,
               deps: 0,
               errored: !0
             }),
@@ -1077,6 +1305,7 @@ function parseModelString(response, parentObject, key, value) {
             parent: initializingHandler,
             chunk: null,
             value: null,
+            reason: null,
             deps: 0,
             errored: !1
           }),
@@ -1092,9 +1321,10 @@ function parseModelString(response, parentObject, key, value) {
           createLazyChunkWrapper(response)
         );
       case "@":
-        if (2 === value.length) return new Promise(function () {});
-        parentObject = parseInt(value.slice(2), 16);
-        return getChunk(response, parentObject);
+        return (
+          (parentObject = parseInt(value.slice(2), 16)),
+          getChunk(response, parentObject)
+        );
       case "S":
         return Symbol.for(value.slice(2));
       case "F":
@@ -1188,19 +1418,21 @@ function ResponseInstance(
   this._chunks = chunks;
   this._stringDecoder = new util.TextDecoder();
   this._fromJSON = null;
-  this._rowLength = this._rowTag = this._rowID = this._rowState = 0;
-  this._buffer = [];
   this._closed = !1;
   this._closedReason = null;
   this._tempRefs = temporaryReferences;
   this._fromJSON = createFromJSONCallback(this);
 }
+function createStreamState() {
+  return { _rowState: 0, _rowID: 0, _rowTag: 0, _rowLength: 0, _buffer: [] };
+}
 function resolveBuffer(response, id, buffer) {
-  var chunks = response._chunks,
-    chunk = chunks.get(id);
+  response = response._chunks;
+  var chunk = response.get(id);
   chunk && "pending" !== chunk.status
     ? chunk.reason.enqueueValue(buffer)
-    : chunks.set(id, new ReactPromise("fulfilled", buffer, null, response));
+    : ((buffer = new ReactPromise("fulfilled", buffer, null)),
+      response.set(id, buffer));
 }
 function resolveModule(response, id, model) {
   var chunks = response._chunks,
@@ -1217,38 +1449,34 @@ function resolveModule(response, id, model) {
       var blockedChunk = chunk;
       blockedChunk.status = "blocked";
     } else
-      (blockedChunk = new ReactPromise("blocked", null, null, response)),
+      (blockedChunk = new ReactPromise("blocked", null, null)),
         chunks.set(id, blockedChunk);
     model.then(
       function () {
-        return resolveModuleChunk(blockedChunk, clientReference);
+        return resolveModuleChunk(response, blockedChunk, clientReference);
       },
       function (error) {
-        return triggerErrorOnChunk(blockedChunk, error);
+        return triggerErrorOnChunk(response, blockedChunk, error);
       }
     );
   } else
     chunk
-      ? resolveModuleChunk(chunk, clientReference)
-      : chunks.set(
-          id,
-          new ReactPromise("resolved_module", clientReference, null, response)
-        );
+      ? resolveModuleChunk(response, chunk, clientReference)
+      : ((chunk = new ReactPromise("resolved_module", clientReference, null)),
+        chunks.set(id, chunk));
 }
 function resolveStream(response, id, stream, controller) {
-  var chunks = response._chunks,
-    chunk = chunks.get(id);
+  response = response._chunks;
+  var chunk = response.get(id);
   chunk
     ? "pending" === chunk.status &&
-      ((response = chunk.value),
+      ((id = chunk.value),
       (chunk.status = "fulfilled"),
       (chunk.value = stream),
       (chunk.reason = controller),
-      null !== response && wakeChunk(response, chunk.value))
-    : chunks.set(
-        id,
-        new ReactPromise("fulfilled", stream, controller, response)
-      );
+      null !== id && wakeChunk(id, chunk.value))
+    : ((stream = new ReactPromise("fulfilled", stream, controller)),
+      response.set(id, stream));
 }
 function startReadableStream(response, id, type) {
   var controller = null;
@@ -1269,7 +1497,7 @@ function startReadableStream(response, id, type) {
     },
     enqueueModel: function (json) {
       if (null === previousBlockedChunk) {
-        var chunk = new ReactPromise("resolved_model", json, null, response);
+        var chunk = new ReactPromise("resolved_model", json, response);
         initializeModelChunk(chunk);
         "fulfilled" === chunk.status
           ? controller.enqueue(chunk.value)
@@ -1284,8 +1512,8 @@ function startReadableStream(response, id, type) {
             (previousBlockedChunk = chunk));
       } else {
         chunk = previousBlockedChunk;
-        var chunk$52 = createPendingChunk(response);
-        chunk$52.then(
+        var chunk$54 = new ReactPromise("pending", null, null);
+        chunk$54.then(
           function (v) {
             return controller.enqueue(v);
           },
@@ -1293,10 +1521,10 @@ function startReadableStream(response, id, type) {
             return controller.error(e);
           }
         );
-        previousBlockedChunk = chunk$52;
+        previousBlockedChunk = chunk$54;
         chunk.then(function () {
-          previousBlockedChunk === chunk$52 && (previousBlockedChunk = null);
-          resolveModelChunk(chunk$52, json);
+          previousBlockedChunk === chunk$54 && (previousBlockedChunk = null);
+          resolveModelChunk(response, chunk$54, json);
         });
       }
     },
@@ -1334,41 +1562,37 @@ function startAsyncIterable(response, id, iterator) {
   var buffer = [],
     closed = !1,
     nextWriteIndex = 0,
-    $jscomp$compprop0 = {};
-  $jscomp$compprop0 =
-    (($jscomp$compprop0[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."
+    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
           );
-        if (nextReadIndex === buffer.length) {
-          if (closed)
-            return new ReactPromise(
-              "fulfilled",
-              { done: !0, value: void 0 },
-              null,
-              response
-            );
-          buffer[nextReadIndex] = createPendingChunk(response);
-        }
-        return buffer[nextReadIndex++];
-      });
-    }),
-    $jscomp$compprop0);
+        buffer[nextReadIndex] = new ReactPromise("pending", null, null);
+      }
+      return buffer[nextReadIndex++];
+    });
+  };
   resolveStream(
     response,
     id,
-    iterator ? $jscomp$compprop0[ASYNC_ITERATOR]() : $jscomp$compprop0,
+    iterator ? iterable[ASYNC_ITERATOR]() : iterable,
     {
       enqueueValue: function (value) {
         if (nextWriteIndex === buffer.length)
           buffer[nextWriteIndex] = new ReactPromise(
             "fulfilled",
             { done: !1, value: value },
-            null,
-            response
+            null
           );
         else {
           var chunk = buffer[nextWriteIndex],
@@ -1388,7 +1612,12 @@ function startAsyncIterable(response, id, iterator) {
               value,
               !1
             ))
-          : resolveIteratorResultChunk(buffer[nextWriteIndex], value, !1);
+          : resolveIteratorResultChunk(
+              response,
+              buffer[nextWriteIndex],
+              value,
+              !1
+            );
         nextWriteIndex++;
       },
       close: function (value) {
@@ -1399,9 +1628,15 @@ function startAsyncIterable(response, id, iterator) {
               value,
               !0
             ))
-          : resolveIteratorResultChunk(buffer[nextWriteIndex], value, !0);
+          : resolveIteratorResultChunk(
+              response,
+              buffer[nextWriteIndex],
+              value,
+              !0
+            );
         for (nextWriteIndex++; nextWriteIndex < buffer.length; )
           resolveIteratorResultChunk(
+            response,
             buffer[nextWriteIndex++],
             '"$undefined"',
             !0
@@ -1411,11 +1646,11 @@ function startAsyncIterable(response, id, iterator) {
         closed = !0;
         for (
           nextWriteIndex === buffer.length &&
-          (buffer[nextWriteIndex] = createPendingChunk(response));
+          (buffer[nextWriteIndex] = new ReactPromise("pending", null, null));
           nextWriteIndex < buffer.length;
 
         )
-          triggerErrorOnChunk(buffer[nextWriteIndex++], error);
+          triggerErrorOnChunk(response, buffer[nextWriteIndex++], error);
       }
     }
   );
@@ -1431,8 +1666,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$53 = (i = 0); i$53 < l; i$53++) {
-    var chunk = buffer[i$53];
+  for (var i$55 = (i = 0); i$55 < l; i$55++) {
+    var chunk = buffer[i$55];
     byteLength.set(chunk, i);
     i += chunk.byteLength;
   }
@@ -1458,7 +1693,7 @@ function resolveTypedArray(
   );
   resolveBuffer(response, id, constructor);
 }
-function processFullBinaryRow(response, id, tag, buffer, chunk) {
+function processFullBinaryRow(response, streamState, id, tag, buffer, chunk) {
   switch (tag) {
     case 65:
       resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
@@ -1511,9 +1746,9 @@ function processFullBinaryRow(response, id, tag, buffer, chunk) {
   )
     row += stringDecoder.decode(buffer[i], decoderOptions);
   row += stringDecoder.decode(chunk);
-  processFullStringRow(response, id, tag, row);
+  processFullStringRow(response, streamState, id, tag, row);
 }
-function processFullStringRow(response, id, tag, row) {
+function processFullStringRow(response, streamState, id, tag, row) {
   switch (tag) {
     case 73:
       resolveModule(response, id, row);
@@ -1534,8 +1769,10 @@ function processFullStringRow(response, id, tag, row) {
           break;
         case "L":
           id = response[0];
-          tag = response[1];
-          3 === response.length ? row.L(id, tag, response[2]) : row.L(id, tag);
+          streamState = response[1];
+          3 === response.length
+            ? row.L(id, streamState, response[2])
+            : row.L(id, streamState);
           break;
         case "m":
           "string" === typeof response
@@ -1563,23 +1800,26 @@ function processFullStringRow(response, id, tag, row) {
       }
       break;
     case 69:
-      tag = JSON.parse(row);
-      row = resolveErrorProd();
-      row.digest = tag.digest;
-      tag = response._chunks;
-      var chunk = tag.get(id);
-      chunk
-        ? triggerErrorOnChunk(chunk, row)
-        : tag.set(id, new ReactPromise("rejected", null, row, response));
+      streamState = response._chunks;
+      tag = streamState.get(id);
+      row = JSON.parse(row);
+      var error = resolveErrorProd();
+      error.digest = row.digest;
+      tag
+        ? triggerErrorOnChunk(response, tag, error)
+        : ((response = new ReactPromise("rejected", null, error)),
+          streamState.set(id, response));
       break;
     case 84:
-      tag = response._chunks;
-      (chunk = tag.get(id)) && "pending" !== chunk.status
-        ? chunk.reason.enqueueValue(row)
-        : tag.set(id, new ReactPromise("fulfilled", row, null, response));
+      response = response._chunks;
+      (streamState = response.get(id)) && "pending" !== streamState.status
+        ? streamState.reason.enqueueValue(row)
+        : ((row = new ReactPromise("fulfilled", row, null)),
+          response.set(id, row));
       break;
     case 78:
     case 68:
+    case 74:
     case 87:
       throw Error(
         "Failed to read a RSC payload created by a development version of React on the server while using a production version on the client. Always use matching versions on the server and the client."
@@ -1597,20 +1837,103 @@ function processFullStringRow(response, id, tag, row) {
       startAsyncIterable(response, id, !0);
       break;
     case 67:
-      (response = response._chunks.get(id)) &&
-        "fulfilled" === response.status &&
-        response.reason.close("" === row ? '"$undefined"' : row);
+      (id = response._chunks.get(id)) &&
+        "fulfilled" === id.status &&
+        id.reason.close("" === row ? '"$undefined"' : row);
       break;
     default:
-      (tag = response._chunks),
-        (chunk = tag.get(id))
-          ? resolveModelChunk(chunk, row)
-          : tag.set(
-              id,
-              new ReactPromise("resolved_model", row, null, response)
-            );
+      (streamState = response._chunks),
+        (tag = streamState.get(id))
+          ? resolveModelChunk(response, tag, row)
+          : ((response = new ReactPromise("resolved_model", row, response)),
+            streamState.set(id, response));
   }
 }
+function processBinaryChunk(weakResponse, streamState, chunk) {
+  for (
+    var i = 0,
+      rowState = streamState._rowState,
+      rowID = streamState._rowID,
+      rowTag = streamState._rowTag,
+      rowLength = streamState._rowLength,
+      buffer = streamState._buffer,
+      chunkLength = chunk.length;
+    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 ||
+        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)),
+        processFullBinaryRow(
+          weakResponse,
+          streamState,
+          rowID,
+          rowTag,
+          buffer,
+          rowLength
+        ),
+        (i = lastIdx),
+        3 === rowState && i++,
+        (rowLength = rowID = rowTag = rowState = 0),
+        (buffer.length = 0);
+    else {
+      weakResponse = new Uint8Array(chunk.buffer, offset, chunk.byteLength - i);
+      buffer.push(weakResponse);
+      rowLength -= weakResponse.byteLength;
+      break;
+    }
+  }
+  streamState._rowState = rowState;
+  streamState._rowID = rowID;
+  streamState._rowTag = rowTag;
+  streamState._rowLength = rowLength;
+}
 function createFromJSONCallback(response) {
   return function (key, value) {
     if ("string" === typeof value)
@@ -1632,15 +1955,10 @@ function createFromJSONCallback(response) {
             (initializingHandler = value.parent),
             value.errored)
           )
-            (key = new ReactPromise("rejected", null, value.value, response)),
+            (key = new ReactPromise("rejected", null, value.reason)),
               (key = createLazyChunkWrapper(key));
           else if (0 < value.deps) {
-            var blockedChunk = new ReactPromise(
-              "blocked",
-              null,
-              null,
-              response
-            );
+            var blockedChunk = new ReactPromise("blocked", null, null);
             value.value = key;
             value.chunk = blockedChunk;
             key = createLazyChunkWrapper(blockedChunk);
@@ -1651,34 +1969,57 @@ function createFromJSONCallback(response) {
     return value;
   };
 }
-function noServerCall() {
+function close(weakResponse) {
+  reportGlobalError(weakResponse, Error("Connection closed."));
+}
+function noServerCall$1() {
   throw Error(
     "Server Functions cannot be called during initial render. This would create a fetch waterfall. Try to use a Server Component to pass data to Client Components instead."
   );
 }
-exports.createFromNodeStream = function (
-  stream,
-  serverConsumerManifest,
-  options
-) {
-  var response = new ResponseInstance(
-    serverConsumerManifest.moduleMap,
-    serverConsumerManifest.serverModuleMap,
-    serverConsumerManifest.moduleLoading,
-    noServerCall,
-    options ? options.encodeFormAction : void 0,
-    options && "string" === typeof options.nonce ? options.nonce : void 0,
-    void 0
+function createResponseFromOptions(options) {
+  return new ResponseInstance(
+    options.serverConsumerManifest.moduleMap,
+    options.serverConsumerManifest.serverModuleMap,
+    options.serverConsumerManifest.moduleLoading,
+    noServerCall$1,
+    options.encodeFormAction,
+    "string" === typeof options.nonce ? options.nonce : void 0,
+    options && options.temporaryReferences
+      ? options.temporaryReferences
+      : void 0
+  );
+}
+function startReadingFromStream$1(response, stream, onDone) {
+  function progress(_ref) {
+    var value = _ref.value;
+    if (_ref.done) return onDone();
+    processBinaryChunk(response, streamState, value);
+    return reader.read().then(progress).catch(error);
+  }
+  function error(e) {
+    reportGlobalError(response, e);
+  }
+  var streamState = createStreamState(),
+    reader = stream.getReader();
+  reader.read().then(progress).catch(error);
+}
+function noServerCall() {
+  throw Error(
+    "Server Functions cannot be called during initial render. This would create a fetch waterfall. Try to use a Server Component to pass data to Client Components instead."
   );
+}
+function startReadingFromStream(response, stream, onEnd) {
+  var streamState = createStreamState();
   stream.on("data", function (chunk) {
     if ("string" === typeof chunk) {
       for (
         var i = 0,
-          rowState = response._rowState,
-          rowID = response._rowID,
-          rowTag = response._rowTag,
-          rowLength = response._rowLength,
-          buffer = response._buffer,
+          rowState = streamState._rowState,
+          rowID = streamState._rowID,
+          rowTag = streamState._rowTag,
+          rowLength = streamState._rowLength,
+          buffer = streamState._buffer,
           chunkLength = chunk.length;
         i < chunkLength;
 
@@ -1743,7 +2084,7 @@ exports.createFromNodeStream = function (
               "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 = chunk.slice(i, lastIdx);
-          processFullStringRow(response, rowID, rowTag, i);
+          processFullStringRow(response, streamState, rowID, rowTag, i);
           i = lastIdx;
           3 === rowState && i++;
           rowLength = rowID = rowTag = rowState = 0;
@@ -1753,105 +2094,84 @@ exports.createFromNodeStream = function (
             "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."
           );
       }
-      response._rowState = rowState;
-      response._rowID = rowID;
-      response._rowTag = rowTag;
-      response._rowLength = rowLength;
-    } else {
-      rowLength = 0;
-      chunkLength = response._rowState;
-      rowID = response._rowID;
-      i = response._rowTag;
-      rowState = response._rowLength;
-      buffer = response._buffer;
-      for (rowTag = chunk.length; rowLength < rowTag; ) {
-        lastIdx = -1;
-        switch (chunkLength) {
-          case 0:
-            lastIdx = chunk[rowLength++];
-            58 === lastIdx
-              ? (chunkLength = 1)
-              : (rowID =
-                  (rowID << 4) | (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
-            continue;
-          case 1:
-            chunkLength = chunk[rowLength];
-            84 === chunkLength ||
-            65 === chunkLength ||
-            79 === chunkLength ||
-            111 === chunkLength ||
-            85 === chunkLength ||
-            83 === chunkLength ||
-            115 === chunkLength ||
-            76 === chunkLength ||
-            108 === chunkLength ||
-            71 === chunkLength ||
-            103 === chunkLength ||
-            77 === chunkLength ||
-            109 === chunkLength ||
-            86 === chunkLength
-              ? ((i = chunkLength), (chunkLength = 2), rowLength++)
-              : (64 < chunkLength && 91 > chunkLength) ||
-                  35 === chunkLength ||
-                  114 === chunkLength ||
-                  120 === chunkLength
-                ? ((i = chunkLength), (chunkLength = 3), rowLength++)
-                : ((i = 0), (chunkLength = 3));
-            continue;
-          case 2:
-            lastIdx = chunk[rowLength++];
-            44 === lastIdx
-              ? (chunkLength = 4)
-              : (rowState =
-                  (rowState << 4) |
-                  (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
-            continue;
-          case 3:
-            lastIdx = chunk.indexOf(10, rowLength);
-            break;
-          case 4:
-            (lastIdx = rowLength + rowState),
-              lastIdx > chunk.length && (lastIdx = -1);
-        }
-        var offset = chunk.byteOffset + rowLength;
-        if (-1 < lastIdx)
-          (rowState = new Uint8Array(
-            chunk.buffer,
-            offset,
-            lastIdx - rowLength
-          )),
-            processFullBinaryRow(response, rowID, i, buffer, rowState),
-            (rowLength = lastIdx),
-            3 === chunkLength && rowLength++,
-            (rowState = rowID = i = chunkLength = 0),
-            (buffer.length = 0);
-        else {
-          chunk = new Uint8Array(
-            chunk.buffer,
-            offset,
-            chunk.byteLength - rowLength
-          );
-          buffer.push(chunk);
-          rowState -= chunk.byteLength;
-          break;
-        }
-      }
-      response._rowState = chunkLength;
-      response._rowID = rowID;
-      response._rowTag = i;
-      response._rowLength = rowState;
-    }
+      streamState._rowState = rowState;
+      streamState._rowID = rowID;
+      streamState._rowTag = rowTag;
+      streamState._rowLength = rowLength;
+    } else processBinaryChunk(response, streamState, chunk);
   });
   stream.on("error", function (error) {
     reportGlobalError(response, error);
   });
-  stream.on("end", function () {
-    reportGlobalError(response, Error("Connection closed."));
-  });
+  stream.on("end", onEnd);
+}
+exports.createFromFetch = function (promiseForResponse, options) {
+  var response = createResponseFromOptions(options);
+  promiseForResponse.then(
+    function (r) {
+      startReadingFromStream$1(response, r.body, close.bind(null, response));
+    },
+    function (e) {
+      reportGlobalError(response, e);
+    }
+  );
   return getChunk(response, 0);
 };
+exports.createFromNodeStream = function (
+  stream,
+  serverConsumerManifest,
+  options
+) {
+  serverConsumerManifest = new ResponseInstance(
+    serverConsumerManifest.moduleMap,
+    serverConsumerManifest.serverModuleMap,
+    serverConsumerManifest.moduleLoading,
+    noServerCall,
+    options ? options.encodeFormAction : void 0,
+    options && "string" === typeof options.nonce ? options.nonce : void 0,
+    void 0
+  );
+  startReadingFromStream(
+    serverConsumerManifest,
+    stream,
+    close.bind(null, serverConsumerManifest)
+  );
+  return getChunk(serverConsumerManifest, 0);
+};
+exports.createFromReadableStream = function (stream, options) {
+  options = createResponseFromOptions(options);
+  startReadingFromStream$1(options, stream, close.bind(null, options));
+  return getChunk(options, 0);
+};
 exports.createServerReference = function (id) {
-  return createServerReference$1(id, noServerCall);
+  return createServerReference$1(id, noServerCall$1);
+};
+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, encodeFormAction) {
   registerBoundServerReference(reference, id, null, encodeFormAction);