@modern-js/runtime 2.54.5 → 2.55.0

package/dist/esm/core/server/requestHandler.js

@@ -0,0 +1,181 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
+import { createRoot } from "../react";
+import { getGlobalAppInit } from "../context";
+import { getGlobalRunner } from "../plugin/runner";
+import { getInitialContext } from "../context/runtime";
+import { createLoaderManager } from "../loader/loaderManager";
+import { getSSRConfigByEntry, getSSRMode } from "./utils";
+import { CHUNK_CSS_PLACEHOLDER } from "./constants";
+function createSSRContext(request, options) {
+  var config = options.config, loaderContext = options.loaderContext, onError = options.onError, onTiming = options.onTiming, locals = options.locals, resource = options.resource, params = options.params, responseProxy = options.responseProxy, staticGenerate = options.staticGenerate, logger = options.logger, metrics = options.metrics, reporter = options.reporter;
+  var nonce = config.nonce;
+  var entryName = resource.entryName, route = resource.route;
+  var cookie = request.headers.get("cookie");
+  var cookieMap = parseCookie(request);
+  var pathname = getPathname(request);
+  var query = parseQuery(request);
+  var headersData = parseHeaders(request);
+  var url = new URL(request.url);
+  var ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+  var ssrMode = getSSRMode(ssrConfig);
+  var loaderFailureMode = typeof ssrConfig === "object" ? ssrConfig.loaderFailureMode : void 0;
+  return {
+    nonce,
+    loaderContext,
+    redirection: {},
+    htmlModifiers: [],
+    logger,
+    metrics,
+    request: {
+      baseUrl: route.urlPath,
+      userAgent: request.headers.get("user-agent"),
+      cookie,
+      cookieMap,
+      pathname,
+      query,
+      params,
+      headers: headersData,
+      host: url.host,
+      raw: request
+    },
+    response: {
+      setHeader: function setHeader(key, value) {
+        responseProxy.headers[key] = value;
+      },
+      status: function status(code) {
+        responseProxy.code = code;
+      },
+      locals: locals || {}
+    },
+    reporter,
+    mode: ssrMode,
+    onError,
+    onTiming,
+    loaderFailureMode
+  };
+}
+var createRequestHandler = function() {
+  var _ref = _async_to_generator(function(handleRequest) {
+    var requestHandler;
+    return _ts_generator(this, function(_state) {
+      requestHandler = function() {
+        var _ref2 = _async_to_generator(function(request, options) {
+          var Root, runner, routeManifest, context, runInit, responseProxy, ssrContext, getRedirectResponse, initialData, redirectResponse, htmlTemplate, response;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                Root = createRoot();
+                runner = getGlobalRunner();
+                routeManifest = options.resource.routeManifest;
+                context = getInitialContext(runner, false, routeManifest);
+                runInit = function(_context) {
+                  return runner.init({
+                    context: _context
+                  }, {
+                    onLast: function(param) {
+                      var context1 = param.context;
+                      var init = getGlobalAppInit();
+                      return init === null || init === void 0 ? void 0 : init(context1);
+                    }
+                  });
+                };
+                responseProxy = {
+                  headers: {},
+                  code: -1
+                };
+                ssrContext = createSSRContext(request, _object_spread_props(_object_spread({}, options), {
+                  responseProxy
+                }));
+                Object.assign(context, {
+                  ssrContext,
+                  isBrowser: false,
+                  loaderManager: createLoaderManager({}, {
+                    skipNonStatic: options.staticGenerate,
+                    // if not static generate, only non-static loader can exec on prod env
+                    skipStatic: process.env.NODE_ENV === "production" && !options.staticGenerate
+                  })
+                });
+                getRedirectResponse = function(result) {
+                  if (typeof Response !== "undefined" && // fix: ssg workflow doesn't inject Web Response
+                  _instanceof(result, Response) && result.status >= 300 && result.status <= 399) {
+                    var status = result.status;
+                    var redirectUrl = result.headers.get("Location") || "/";
+                    var ssrContext2 = context.ssrContext;
+                    if (ssrContext2) {
+                      return new Response(null, {
+                        status,
+                        headers: {
+                          Location: redirectUrl
+                        }
+                      });
+                    }
+                  }
+                  return void 0;
+                };
+                return [
+                  4,
+                  runInit(context)
+                ];
+              case 1:
+                initialData = _state2.sent();
+                context.initialData = initialData;
+                redirectResponse = getRedirectResponse(initialData);
+                if (redirectResponse) {
+                  return [
+                    2,
+                    redirectResponse
+                  ];
+                }
+                htmlTemplate = options.resource.htmlTemplate;
+                options.resource.htmlTemplate = htmlTemplate.replace("</head>", "".concat(CHUNK_CSS_PLACEHOLDER, "</head>"));
+                return [
+                  4,
+                  handleRequest(request, Root, _object_spread_props(_object_spread({}, options), {
+                    runtimeContext: context
+                  }))
+                ];
+              case 2:
+                response = _state2.sent();
+                Object.entries(responseProxy.headers).forEach(function(param) {
+                  var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                  response.headers.set(key, value);
+                });
+                if (responseProxy.code !== -1) {
+                  return [
+                    2,
+                    new Response(response.body, {
+                      status: responseProxy.code,
+                      headers: response.headers
+                    })
+                  ];
+                }
+                return [
+                  2,
+                  response
+                ];
+            }
+          });
+        });
+        return function requestHandler2(request, options) {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+      return [
+        2,
+        requestHandler
+      ];
+    });
+  });
+  return function createRequestHandler2(handleRequest) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createRequestHandler
+};

package/dist/esm/core/server/server.js

@@ -0,0 +1,8 @@
+import { renderString } from "./string";
+import { renderStreaming } from "./stream";
+import { createRequestHandler } from "./requestHandler";
+export {
+  createRequestHandler,
+  renderStreaming,
+  renderString
+};

package/dist/esm/core/server/shared.js

@@ -0,0 +1,10 @@
+function buildHtml(template, callbacks) {
+  return callbacks.reduce(function(promise, buildHtmlCb) {
+    return promise.then(function(template2) {
+      return buildHtmlCb(template2);
+    });
+  }, Promise.resolve(template));
+}
+export {
+  buildHtml
+};

package/dist/esm/core/server/stream/afterTemplate.js

@@ -0,0 +1,60 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { attributesToString, safeReplace } from "../utils";
+import { SSR_DATA_PLACEHOLDER } from "../constants";
+import { buildHtml } from "../shared";
+function buildShellAfterTemplate(afterAppTemplate, options) {
+  var request = options.request, config = options.config, ssrConfig = options.ssrConfig, runtimeContext = options.runtimeContext, renderLevel = options.renderLevel;
+  var callbacks = [
+    createReplaceSSRData({
+      request,
+      ssrConfig,
+      nonce: config.nonce,
+      runtimeContext,
+      renderLevel
+    })
+  ];
+  return buildHtml(afterAppTemplate, callbacks);
+}
+function createReplaceSSRData(options) {
+  var runtimeContext = options.runtimeContext, nonce = options.nonce, renderLevel = options.renderLevel, ssrConfig = options.ssrConfig;
+  var _runtimeContext_ssrContext = runtimeContext.ssrContext, request = _runtimeContext_ssrContext.request, reporter = _runtimeContext_ssrContext.reporter;
+  var headers = typeof ssrConfig === "object" && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(function(param) {
+    var _param = _sliced_to_array(param, 2), key = _param[0], _ = _param[1];
+    var _ssrConfig_unsafeHeaders_map, _ssrConfig_unsafeHeaders;
+    return (_ssrConfig_unsafeHeaders = ssrConfig.unsafeHeaders) === null || _ssrConfig_unsafeHeaders === void 0 ? void 0 : (_ssrConfig_unsafeHeaders_map = _ssrConfig_unsafeHeaders.map(function(header) {
+      return header.toLowerCase();
+    })) === null || _ssrConfig_unsafeHeaders_map === void 0 ? void 0 : _ssrConfig_unsafeHeaders_map.includes(key.toLowerCase());
+  })) : void 0;
+  var ssrData = {
+    data: {
+      initialData: runtimeContext.initialData,
+      i18nData: runtimeContext.__i18nData__
+    },
+    context: {
+      reporter: {
+        sessionId: reporter === null || reporter === void 0 ? void 0 : reporter.sessionId
+      },
+      request: {
+        query: request.query,
+        params: request.params,
+        pathname: request.pathname,
+        host: request.host,
+        url: request.raw.url,
+        headers
+      }
+    },
+    mode: "stream",
+    renderLevel
+  };
+  var attrsStr = attributesToString({
+    nonce
+  });
+  var ssrDataScript = "\n    <script".concat(attrsStr, ">window._SSR_DATA = ").concat(serializeJson(ssrData), "</script>\n    ");
+  return function(template) {
+    return safeReplace(template, SSR_DATA_PLACEHOLDER, ssrDataScript);
+  };
+}
+export {
+  buildShellAfterTemplate
+};

package/dist/esm/{ssr/serverRender/renderToStream/bulidTemplate.before.js → core/server/stream/beforeTemplate.js}

@@ -4,10 +4,10 @@ import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import ReactHelmet from "react-helmet";
 import { matchRoutes } from "@modern-js/runtime-utils/router";
-import helmetReplace from "../helmet";
+import { createReplaceHelemt } from "../helmet";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants";
 import { checkIsNode, safeReplace } from "../utils";
-import { buildTemplate } from "./buildTemplate.share";
+import { buildHtml } from "../shared";
 var readAsset = function() {
   var _ref = _async_to_generator(function(chunk) {
     var fs, path, filepath;
@@ -49,12 +49,12 @@ var checkIsInline = function(chunk, enableInline) {
     return false;
   }
 };
-function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig, styledComponentsStyleTags) {
+function buildShellBeforeTemplate(beforeAppTemplate, options) {
   return _buildShellBeforeTemplate.apply(this, arguments);
 }
 function _buildShellBeforeTemplate() {
-  _buildShellBeforeTemplate = _async_to_generator(function(beforeAppTemplate, context, pluginConfig, styledComponentsStyleTags) {
-    var helmetData, callbacks;
+  _buildShellBeforeTemplate = _async_to_generator(function(beforeAppTemplate, options) {
+    var config, runtimeContext, styledComponentsStyleTags, helmetData, callbacks;
     function injectCss(template, styledComponentsStyleTags2) {
       return _injectCss.apply(this, arguments);
     }
@@ -70,7 +70,7 @@ function _buildShellBeforeTemplate() {
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
-                  routeManifest = context.routeManifest, routerContext = context.routerContext, routes = context.routes;
+                  routeManifest = runtimeContext.routeManifest, routerContext = runtimeContext.routerContext, routes = runtimeContext.routes;
                   if (!routeManifest || !routerContext || !routes) {
                     return [
                       2,
@@ -97,7 +97,7 @@ function _buildShellBeforeTemplate() {
                       }
                     }
                   });
-                  enableInlineStyles = pluginConfig.enableInlineStyles;
+                  enableInlineStyles = config.enableInlineStyles;
                   return [
                     4,
                     Promise.all(cssChunks.map(function() {
@@ -163,11 +163,10 @@ function _buildShellBeforeTemplate() {
       return _injectCss.apply(this, arguments);
     }
     return _ts_generator(this, function(_state) {
+      config = options.config, runtimeContext = options.runtimeContext, styledComponentsStyleTags = options.styledComponentsStyleTags;
       helmetData = ReactHelmet.renderStatic();
       callbacks = [
-        function(headTemplate) {
-          return helmetData ? helmetReplace(headTemplate, helmetData) : headTemplate;
-        },
+        createReplaceHelemt(helmetData),
         // @TODO: prefetch scripts of lazy component
         function(template) {
           return injectCss(template, styledComponentsStyleTags);
@@ -175,7 +174,7 @@ function _buildShellBeforeTemplate() {
       ];
       return [
         2,
-        buildTemplate(beforeAppTemplate, callbacks)
+        buildHtml(beforeAppTemplate, callbacks)
       ];
     });
   });

package/dist/esm/{ssr/serverRender/renderToStream/renderToPipe.js → core/server/stream/createReadableStream.js}

@@ -1,51 +1,50 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { Transform } from "stream";
+import { renderToPipeableStream } from "react-dom/server";
+import { createReadableStreamFromReadable } from "@modern-js/runtime-utils/node";
 import { ServerStyleSheet } from "styled-components";
-import { RenderLevel } from "../types";
+import checkIsBot from "isbot";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
+import { RenderLevel } from "../../constants";
 import { getTemplates } from "./template";
-var ShellChunkStatus;
-(function(ShellChunkStatus2) {
-  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
-  ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
-})(ShellChunkStatus || (ShellChunkStatus = {}));
-function renderToPipe(rootElement, context, pluginConfig, options) {
-  var _context_ssrContext;
-  var shellChunkStatus = 0;
+import { ShellChunkStatus, getReadableStreamFromString } from "./shared";
+var createReadableStreamFromElement = function(request, rootElement, options) {
+  var runtimeContext = options.runtimeContext, htmlTemplate = options.htmlTemplate, config = options.config, ssrConfig = options.ssrConfig;
+  var shellChunkStatus = ShellChunkStatus.START;
+  var renderLevel = RenderLevel.SERVER_RENDER;
   var forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
-  var onReady = ((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.isSpider) || forceStream2String ? "onAllReady" : "onShellReady";
+  var isbot = checkIsBot(request.headers.get("user-agent"));
+  var onReady = isbot || forceStream2String ? "onAllReady" : "onShellReady";
   var sheet = new ServerStyleSheet();
-  var ssrContext = context.ssrContext;
   var chunkVec = [];
-  var forUserPipe = new Promise(function(resolve) {
-    var renderToPipeableStream;
-    try {
-      renderToPipeableStream = require("react-dom/server").renderToPipeableStream;
-    } catch (e) {
-    }
-    var root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
-    var renderLevel = RenderLevel.SERVER_RENDER;
+  var root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
+  return new Promise(function(resolve) {
     var _obj;
-    var pipe = renderToPipeableStream(root, _object_spread_props(_object_spread({}, options), (_obj = {
-      nonce: ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.nonce
+    var pipe = renderToPipeableStream(root, (_obj = {
+      nonce: config.nonce
     }, _define_property(_obj, onReady, function() {
+      var _options_onReady;
       var styledComponentsStyleTags = forceStream2String ? sheet.getStyleTags() : "";
-      getTemplates(context, renderLevel, pluginConfig, styledComponentsStyleTags).then(function(param) {
+      (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
+      getTemplates(htmlTemplate, {
+        request,
+        ssrConfig,
+        renderLevel,
+        runtimeContext,
+        config,
+        styledComponentsStyleTags
+      }).then(function(param) {
         var shellAfter = param.shellAfter, shellBefore = param.shellBefore;
-        var _options_onReady;
-        options === null || options === void 0 ? void 0 : (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
-        var injectableTransform = new Transform({
+        var body = new Transform({
           transform: function transform(chunk, _encoding, callback) {
             try {
-              if (shellChunkStatus !== 1) {
+              if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                 chunkVec.push(chunk.toString());
                 var concatedChunk = chunkVec.join("");
                 if (concatedChunk.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
                   concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                  shellChunkStatus = 1;
+                  shellChunkStatus = ShellChunkStatus.FINISH;
                   this.push("".concat(shellBefore).concat(concatedChunk).concat(shellAfter));
                 }
               } else {
@@ -61,27 +60,33 @@ function renderToPipe(rootElement, context, pluginConfig, options) {
             }
           }
         });
-        pipe(injectableTransform);
-        resolve(injectableTransform);
+        var stream = createReadableStreamFromReadable(body);
+        resolve(stream);
+        pipe(body);
       });
     }), _define_property(_obj, "onShellError", function onShellError(error) {
       renderLevel = RenderLevel.CLIENT_RENDER;
-      getTemplates(context, renderLevel, pluginConfig).then(function(param) {
+      getTemplates(htmlTemplate, {
+        request,
+        ssrConfig,
+        renderLevel,
+        runtimeContext,
+        config
+      }).then(function(param) {
         var shellAfter = param.shellAfter, shellBefore = param.shellBefore;
         var _options_onShellError;
         var fallbackHtml = "".concat(shellBefore).concat(shellAfter);
-        resolve(fallbackHtml);
+        var readableStream = getReadableStreamFromString(fallbackHtml);
+        resolve(readableStream);
         options === null || options === void 0 ? void 0 : (_options_onShellError = options.onShellError) === null || _options_onShellError === void 0 ? void 0 : _options_onShellError.call(options, error);
       });
     }), _define_property(_obj, "onError", function onError(error) {
       var _options_onError;
       renderLevel = RenderLevel.CLIENT_RENDER;
       options === null || options === void 0 ? void 0 : (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
-    }), _obj))).pipe;
+    }), _obj)).pipe;
   });
-  return forUserPipe;
-}
-var renderToPipe_default = renderToPipe;
+};
 export {
-  renderToPipe_default as default
+  createReadableStreamFromElement
 };

package/dist/esm/core/server/stream/createReadableStream.worker.js

@@ -0,0 +1,142 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { renderToReadableStream } from "react-dom/server";
+import checkIsBot from "isbot";
+import { RenderLevel } from "../../constants";
+import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
+import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString } from "./shared";
+import { getTemplates } from "./template";
+var createReadableStreamFromElement = function() {
+  var _ref = _async_to_generator(function(request, rootElement, options) {
+    var shellChunkStatus, chunkVec, htmlTemplate, runtimeContext, config, ssrConfig, _ref2, shellBefore, shellAfter, _options_onShellReady, readableOriginal, isbot, reader, stream, e, fallbackHtml, stream1;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          shellChunkStatus = ShellChunkStatus.START;
+          chunkVec = [];
+          htmlTemplate = options.htmlTemplate, runtimeContext = options.runtimeContext, config = options.config, ssrConfig = options.ssrConfig;
+          return [
+            4,
+            getTemplates(htmlTemplate, {
+              renderLevel: RenderLevel.SERVER_RENDER,
+              runtimeContext,
+              ssrConfig,
+              request,
+              config
+            })
+          ];
+        case 1:
+          _ref2 = _state.sent(), shellBefore = _ref2.shellBefore, shellAfter = _ref2.shellAfter;
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            6,
+            ,
+            7
+          ]);
+          return [
+            4,
+            renderToReadableStream(rootElement, {
+              nonce: config.nonce,
+              onError: function onError(error) {
+                var _options_onError;
+                (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
+              }
+            })
+          ];
+        case 3:
+          readableOriginal = _state.sent();
+          (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
+          readableOriginal.allReady.then(function() {
+            var _options_onAllReady;
+            options === null || options === void 0 ? void 0 : (_options_onAllReady = options.onAllReady) === null || _options_onAllReady === void 0 ? void 0 : _options_onAllReady.call(options);
+          });
+          isbot = checkIsBot(request.headers.get("user-agent"));
+          if (!isbot)
+            return [
+              3,
+              5
+            ];
+          return [
+            4,
+            readableOriginal.allReady
+          ];
+        case 4:
+          _state.sent();
+          _state.label = 5;
+        case 5:
+          reader = readableOriginal.getReader();
+          stream = new ReadableStream({
+            start: function start(controller) {
+              function push() {
+                return _push.apply(this, arguments);
+              }
+              function _push() {
+                _push = _async_to_generator(function() {
+                  var _ref3, done, value, chunk, concatedChunk;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        return [
+                          4,
+                          reader.read()
+                        ];
+                      case 1:
+                        _ref3 = _state2.sent(), done = _ref3.done, value = _ref3.value;
+                        if (done) {
+                          controller.close();
+                          return [
+                            2
+                          ];
+                        }
+                        if (shellChunkStatus !== ShellChunkStatus.FINISH) {
+                          chunk = new TextDecoder().decode(value);
+                          chunkVec.push(chunk);
+                          concatedChunk = chunkVec.join("");
+                          if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
+                            concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
+                            shellChunkStatus = ShellChunkStatus.FINISH;
+                            controller.enqueue(encodeForWebStream("".concat(shellBefore).concat(concatedChunk).concat(shellAfter)));
+                          }
+                        } else {
+                          controller.enqueue(value);
+                        }
+                        push();
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return _push.apply(this, arguments);
+              }
+              push();
+            }
+          });
+          return [
+            2,
+            stream
+          ];
+        case 6:
+          e = _state.sent();
+          fallbackHtml = "".concat(shellBefore).concat(shellAfter);
+          stream1 = getReadableStreamFromString(fallbackHtml);
+          return [
+            2,
+            stream1
+          ];
+        case 7:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function createReadableStreamFromElement2(request, rootElement, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createReadableStreamFromElement
+};

package/dist/esm/core/server/stream/index.js

@@ -0,0 +1,6 @@
+import { createReadableStreamFromElement } from "./createReadableStream";
+import { createRenderStreaming } from "./shared";
+var renderStreaming = createRenderStreaming(createReadableStreamFromElement);
+export {
+  renderStreaming
+};