@modern-js/runtime 2.54.5 → 2.55.0

package/dist/cjs/core/react/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_exports = {};
+__export(react_exports, {
+  createRoot: () => createRoot
+});
+module.exports = __toCommonJS(react_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_context = require("../context");
+var import_runner = require("../plugin/runner");
+function createRoot(UserApp, config) {
+  const App = UserApp || (0, import_context.getGlobalApp)();
+  const runner = (0, import_runner.getGlobalRunner)();
+  const HOCApp = runner.hoc({
+    App,
+    config: config || {}
+  }, {
+    onLast: ({ App: App2 }) => {
+      const WrapComponent = ({ _internal_context, ...props }) => {
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_context.RuntimeReactContext.Provider, {
+          value: _internal_context,
+          children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App2, {
+            ...props
+          })
+        });
+      };
+      return WrapComponent;
+    }
+  });
+  return HOCApp;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRoot
+});

package/dist/cjs/{ssr/serverRender → core/server}/helmet.js

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var helmet_exports = {};
 __export(helmet_exports, {
-  default: () => helmet
+  createReplaceHelemt: () => createReplaceHelemt,
+  helmetReplace: () => helmetReplace
 });
 module.exports = __toCommonJS(helmet_exports);
 var import_os = require("os");
@@ -28,7 +29,10 @@ const RE_BODY_ATTR = /<body[^>]*>/;
 const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = RegExp("(?<=<title[^>]*>)([\\s\\S\\n\\r]*?)([.|\\S])([\\s\\S\\n\\r]*?)(?=<\\/title>)");
-function helmet(content, helmetData) {
+function createReplaceHelemt(helmetData) {
+  return helmetData ? (template) => helmetReplace(template, helmetData) : (tempalte) => tempalte;
+}
+function helmetReplace(content, helmetData) {
   let result = content;
   const bodyAttributes = helmetData.bodyAttributes.toString();
   if (bodyAttributes) {
@@ -63,3 +67,8 @@ function helmet(content, helmetData) {
   }, "");
   return (0, import_utils.safeReplace)(result, RE_LAST_IN_HEAD, `${helmetStr}</head>`);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReplaceHelemt,
+  helmetReplace
+});

package/dist/cjs/core/server/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  NoSSR: () => import_react.NoSSR,
+  PreRender: () => import_react.PreRender,
+  default: () => server_default,
+  ssr: () => ssr
+});
+module.exports = __toCommonJS(server_exports);
+var import_react = require("./react");
+const ssr = (_config) => ({
+  name: "@modern-js/plugin-ssr",
+  setup: () => ({})
+});
+var server_default = ssr;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoSSR,
+  PreRender,
+  ssr
+});

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

@@ -0,0 +1,156 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requestHandler_exports = {};
+__export(requestHandler_exports, {
+  createRequestHandler: () => createRequestHandler
+});
+module.exports = __toCommonJS(requestHandler_exports);
+var import_request = require("@modern-js/runtime-utils/universal/request");
+var import_react2 = require("../react");
+var import_context = require("../context");
+var import_runner = require("../plugin/runner");
+var import_runtime = require("../context/runtime");
+var import_loaderManager = require("../loader/loaderManager");
+var import_utils = require("./utils");
+var import_constants = require("./constants");
+function createSSRContext(request, options) {
+  const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, staticGenerate, logger, metrics, reporter } = options;
+  const { nonce } = config;
+  const { entryName, route } = resource;
+  const cookie = request.headers.get("cookie");
+  const cookieMap = (0, import_request.parseCookie)(request);
+  const pathname = (0, import_request.getPathname)(request);
+  const query = (0, import_request.parseQuery)(request);
+  const headersData = (0, import_request.parseHeaders)(request);
+  const url = new URL(request.url);
+  const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+  const ssrMode = (0, import_utils.getSSRMode)(ssrConfig);
+  const 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(key, value) {
+        responseProxy.headers[key] = value;
+      },
+      status(code) {
+        responseProxy.code = code;
+      },
+      locals: locals || {}
+    },
+    reporter,
+    mode: ssrMode,
+    onError,
+    onTiming,
+    loaderFailureMode
+  };
+}
+const createRequestHandler = async (handleRequest) => {
+  const requestHandler = async (request, options) => {
+    const Root = (0, import_react2.createRoot)();
+    const runner = (0, import_runner.getGlobalRunner)();
+    const { routeManifest } = options.resource;
+    const context = (0, import_runtime.getInitialContext)(runner, false, routeManifest);
+    const runInit = (_context) => runner.init({
+      context: _context
+    }, {
+      onLast: ({ context: context1 }) => {
+        const init = (0, import_context.getGlobalAppInit)();
+        return init === null || init === void 0 ? void 0 : init(context1);
+      }
+    });
+    const responseProxy = {
+      headers: {},
+      code: -1
+    };
+    const ssrContext = createSSRContext(request, {
+      ...options,
+      responseProxy
+    });
+    Object.assign(context, {
+      ssrContext,
+      isBrowser: false,
+      loaderManager: (0, import_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
+      })
+    });
+    const getRedirectResponse = (result) => {
+      if (typeof Response !== "undefined" && // fix: ssg workflow doesn't inject Web Response
+      result instanceof Response && result.status >= 300 && result.status <= 399) {
+        const { status } = result;
+        const redirectUrl = result.headers.get("Location") || "/";
+        const { ssrContext: ssrContext2 } = context;
+        if (ssrContext2) {
+          return new Response(null, {
+            status,
+            headers: {
+              Location: redirectUrl
+            }
+          });
+        }
+      }
+      return void 0;
+    };
+    const initialData = await runInit(context);
+    context.initialData = initialData;
+    const redirectResponse = getRedirectResponse(initialData);
+    if (redirectResponse) {
+      return redirectResponse;
+    }
+    const { htmlTemplate } = options.resource;
+    options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
+    const response = await handleRequest(request, Root, {
+      ...options,
+      runtimeContext: context
+    });
+    Object.entries(responseProxy.headers).forEach(([key, value]) => {
+      response.headers.set(key, value);
+    });
+    if (responseProxy.code !== -1) {
+      return new Response(response.body, {
+        status: responseProxy.code,
+        headers: response.headers
+      });
+    }
+    return response;
+  };
+  return requestHandler;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestHandler
+});

package/dist/cjs/core/server/server.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  createRequestHandler: () => import_requestHandler.createRequestHandler,
+  renderStreaming: () => import_stream.renderStreaming,
+  renderString: () => import_string.renderString
+});
+module.exports = __toCommonJS(server_exports);
+var import_string = require("./string");
+var import_stream = require("./stream");
+var import_requestHandler = require("./requestHandler");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestHandler,
+  renderStreaming,
+  renderString
+});

package/dist/cjs/{ssr/serverRender/renderToStream/buildTemplate.share.js → core/server/shared.js}

@@ -16,18 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var buildTemplate_share_exports = {};
-__export(buildTemplate_share_exports, {
-  HEAD_REG_EXP: () => HEAD_REG_EXP,
-  buildTemplate: () => buildTemplate
+var shared_exports = {};
+__export(shared_exports, {
+  buildHtml: () => buildHtml
 });
-module.exports = __toCommonJS(buildTemplate_share_exports);
-const HEAD_REG_EXP = /<head(.|\n)*>(.|\n)*<\/head>/;
-function buildTemplate(template, callbacks) {
-  return callbacks.reduce((promise, buildTemplateCb) => promise.then((template2) => buildTemplateCb(template2)), Promise.resolve(template));
+module.exports = __toCommonJS(shared_exports);
+function buildHtml(template, callbacks) {
+  return callbacks.reduce((promise, buildHtmlCb) => promise.then((template2) => buildHtmlCb(template2)), Promise.resolve(template));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  HEAD_REG_EXP,
-  buildTemplate
+  buildHtml
 });

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

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var afterTemplate_exports = {};
+__export(afterTemplate_exports, {
+  buildShellAfterTemplate: () => buildShellAfterTemplate
+});
+module.exports = __toCommonJS(afterTemplate_exports);
+var import_node = require("@modern-js/runtime-utils/node");
+var import_utils = require("../utils");
+var import_constants = require("../constants");
+var import_shared = require("../shared");
+function buildShellAfterTemplate(afterAppTemplate, options) {
+  const { request, config, ssrConfig, runtimeContext, renderLevel } = options;
+  const callbacks = [
+    createReplaceSSRData({
+      request,
+      ssrConfig,
+      nonce: config.nonce,
+      runtimeContext,
+      renderLevel
+    })
+  ];
+  return (0, import_shared.buildHtml)(afterAppTemplate, callbacks);
+}
+function createReplaceSSRData(options) {
+  const { runtimeContext, nonce, renderLevel, ssrConfig } = options;
+  const { request, reporter } = runtimeContext.ssrContext;
+  const headers = typeof ssrConfig === "object" && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _]) => {
+    var _ssrConfig_unsafeHeaders_map, _ssrConfig_unsafeHeaders;
+    return (_ssrConfig_unsafeHeaders = ssrConfig.unsafeHeaders) === null || _ssrConfig_unsafeHeaders === void 0 ? void 0 : (_ssrConfig_unsafeHeaders_map = _ssrConfig_unsafeHeaders.map((header) => header.toLowerCase())) === null || _ssrConfig_unsafeHeaders_map === void 0 ? void 0 : _ssrConfig_unsafeHeaders_map.includes(key.toLowerCase());
+  })) : void 0;
+  const 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
+  };
+  const attrsStr = (0, import_utils.attributesToString)({
+    nonce
+  });
+  const ssrDataScript = `
+    <script${attrsStr}>window._SSR_DATA = ${(0, import_node.serializeJson)(ssrData)}</script>
+    `;
+  return (template) => (0, import_utils.safeReplace)(template, import_constants.SSR_DATA_PLACEHOLDER, ssrDataScript);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildShellAfterTemplate
+});

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

@@ -26,17 +26,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var bulidTemplate_before_exports = {};
-__export(bulidTemplate_before_exports, {
+var beforeTemplate_exports = {};
+__export(beforeTemplate_exports, {
   buildShellBeforeTemplate: () => buildShellBeforeTemplate
 });
-module.exports = __toCommonJS(bulidTemplate_before_exports);
+module.exports = __toCommonJS(beforeTemplate_exports);
 var import_react_helmet = __toESM(require("react-helmet"));
 var import_router = require("@modern-js/runtime-utils/router");
-var import_helmet = __toESM(require("../helmet"));
+var import_helmet = require("../helmet");
 var import_constants = require("../constants");
 var import_utils = require("../utils");
-var import_buildTemplate = require("./buildTemplate.share");
+var import_shared = require("../shared");
 const readAsset = async (chunk) => {
   const fs = await Promise.resolve().then(() => __toESM(require("fs/promises")));
   const path = await Promise.resolve().then(() => __toESM(require("path")));
@@ -54,16 +54,15 @@ const checkIsInline = (chunk, enableInline) => {
     return false;
   }
 };
-async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig, styledComponentsStyleTags) {
+async function buildShellBeforeTemplate(beforeAppTemplate, options) {
+  const { config, runtimeContext, styledComponentsStyleTags } = options;
   const helmetData = import_react_helmet.default.renderStatic();
   const callbacks = [
-    (headTemplate) => {
-      return helmetData ? (0, import_helmet.default)(headTemplate, helmetData) : headTemplate;
-    },
+    (0, import_helmet.createReplaceHelemt)(helmetData),
     // @TODO: prefetch scripts of lazy component
     (template) => injectCss(template, styledComponentsStyleTags)
   ];
-  return (0, import_buildTemplate.buildTemplate)(beforeAppTemplate, callbacks);
+  return (0, import_shared.buildHtml)(beforeAppTemplate, callbacks);
   async function injectCss(template, styledComponentsStyleTags2) {
     let css = await getCssChunks();
     if (styledComponentsStyleTags2) {
@@ -71,7 +70,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig
     }
     return (0, import_utils.safeReplace)(template, import_constants.CHUNK_CSS_PLACEHOLDER, css);
     async function getCssChunks() {
-      const { routeManifest, routerContext, routes } = context;
+      const { routeManifest, routerContext, routes } = runtimeContext;
       if (!routeManifest || !routerContext || !routes) {
         return "";
       }
@@ -92,7 +91,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig
           }
         }
       });
-      const { enableInlineStyles } = pluginConfig;
+      const { enableInlineStyles } = config;
       const styles = await Promise.all(cssChunks.map(async (chunk) => {
         const link = `<link href="${chunk}" rel="stylesheet" />`;
         if ((0, import_utils.checkIsNode)() && checkIsInline(chunk, enableInlineStyles)) {

package/dist/cjs/core/server/stream/createReadableStream.js

@@ -0,0 +1,124 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createReadableStream_exports = {};
+__export(createReadableStream_exports, {
+  createReadableStreamFromElement: () => createReadableStreamFromElement
+});
+module.exports = __toCommonJS(createReadableStream_exports);
+var import_stream = require("stream");
+var import_server = require("react-dom/server");
+var import_node = require("@modern-js/runtime-utils/node");
+var import_styled_components = require("styled-components");
+var import_isbot = __toESM(require("isbot"));
+var import_common = require("../../../common");
+var import_constants = require("../../constants");
+var import_template = require("./template");
+var import_shared = require("./shared");
+const createReadableStreamFromElement = (request, rootElement, options) => {
+  const { runtimeContext, htmlTemplate, config, ssrConfig } = options;
+  let shellChunkStatus = import_shared.ShellChunkStatus.START;
+  let renderLevel = import_constants.RenderLevel.SERVER_RENDER;
+  const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
+  const isbot = (0, import_isbot.default)(request.headers.get("user-agent"));
+  const onReady = isbot || forceStream2String ? "onAllReady" : "onShellReady";
+  const sheet = new import_styled_components.ServerStyleSheet();
+  const chunkVec = [];
+  const root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
+  return new Promise((resolve) => {
+    const { pipe } = (0, import_server.renderToPipeableStream)(root, {
+      nonce: config.nonce,
+      [onReady]() {
+        var _options_onReady;
+        const styledComponentsStyleTags = forceStream2String ? sheet.getStyleTags() : "";
+        (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
+        (0, import_template.getTemplates)(htmlTemplate, {
+          request,
+          ssrConfig,
+          renderLevel,
+          runtimeContext,
+          config,
+          styledComponentsStyleTags
+        }).then(({ shellAfter, shellBefore }) => {
+          const body = new import_stream.Transform({
+            transform(chunk, _encoding, callback) {
+              try {
+                if (shellChunkStatus !== import_shared.ShellChunkStatus.FINISH) {
+                  chunkVec.push(chunk.toString());
+                  let concatedChunk = chunkVec.join("");
+                  if (concatedChunk.includes(import_common.ESCAPED_SHELL_STREAM_END_MARK)) {
+                    concatedChunk = concatedChunk.replace(import_common.ESCAPED_SHELL_STREAM_END_MARK, "");
+                    shellChunkStatus = import_shared.ShellChunkStatus.FINISH;
+                    this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+                  }
+                } else {
+                  this.push(chunk);
+                }
+                callback();
+              } catch (e) {
+                if (e instanceof Error) {
+                  callback(e);
+                } else {
+                  callback(new Error("Received unkown error when streaming"));
+                }
+              }
+            }
+          });
+          const stream = (0, import_node.createReadableStreamFromReadable)(body);
+          resolve(stream);
+          pipe(body);
+        });
+      },
+      onShellError(error) {
+        renderLevel = import_constants.RenderLevel.CLIENT_RENDER;
+        (0, import_template.getTemplates)(htmlTemplate, {
+          request,
+          ssrConfig,
+          renderLevel,
+          runtimeContext,
+          config
+        }).then(({ shellAfter, shellBefore }) => {
+          var _options_onShellError;
+          const fallbackHtml = `${shellBefore}${shellAfter}`;
+          const readableStream = (0, import_shared.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);
+        });
+      },
+      onError(error) {
+        var _options_onError;
+        renderLevel = import_constants.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);
+      }
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReadableStreamFromElement
+});