@modern-js/runtime 2.69.7 → 3.0.0-alpha.1

package/dist/esm-node/core/server/stream/beforeTemplate.js

@@ -1,85 +0,0 @@
-import { matchRoutes } from "@modern-js/runtime-utils/router";
-import ReactHelmet from "react-helmet";
-import { CHUNK_CSS_PLACEHOLDER } from "../constants";
-import { createReplaceHelemt } from "../helmet";
-import { buildHtml } from "../shared";
-import { checkIsNode, safeReplace } from "../utils";
-const readAsset = async (chunk) => {
-  const fs = await import("fs/promises");
-  const path = await import("path");
-  const filepath = path.join(__dirname, chunk);
-  return fs.readFile(filepath, "utf-8");
-};
-const checkIsInline = (chunk, enableInline) => {
-  if (process.env.NODE_ENV === "production") {
-    if (enableInline instanceof RegExp) {
-      return enableInline.test(chunk);
-    } else {
-      return Boolean(enableInline);
-    }
-  } else {
-    return false;
-  }
-};
-async function buildShellBeforeTemplate(beforeAppTemplate, options) {
-  const { config, runtimeContext, styledComponentsStyleTags, entryName } = options;
-  const helmetData = ReactHelmet.renderStatic();
-  const callbacks = [
-    createReplaceHelemt(helmetData),
-    // @TODO: prefetch scripts of lazy component
-    (template) => injectCss(template, entryName, styledComponentsStyleTags)
-  ];
-  return buildHtml(beforeAppTemplate, callbacks);
-  async function injectCss(template, entryName2, styledComponentsStyleTags2) {
-    let css = await getCssChunks();
-    if (styledComponentsStyleTags2) {
-      css += styledComponentsStyleTags2;
-    }
-    return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
-    async function getCssChunks() {
-      const { routeManifest, routerContext, routes } = runtimeContext;
-      if (!routeManifest || !routerContext || !routes) {
-        return "";
-      }
-      const { routeAssets } = routeManifest;
-      const matches = matchRoutes(routes, routerContext.location, routerContext.basename);
-      const matchedRouteManifests = matches === null || matches === void 0 ? void 0 : matches.map((match, index) => {
-        if (!index) {
-          return;
-        }
-        const routeId = match.route.id;
-        if (routeId) {
-          const routeManifest2 = routeAssets[routeId];
-          return routeManifest2;
-        }
-      }).filter(Boolean);
-      const asyncEntry = routeAssets[`async-${entryName2}`];
-      if (asyncEntry) {
-        matchedRouteManifests === null || matchedRouteManifests === void 0 ? void 0 : matchedRouteManifests.push(asyncEntry);
-      }
-      const cssChunks = matchedRouteManifests ? matchedRouteManifests === null || matchedRouteManifests === void 0 ? void 0 : matchedRouteManifests.reduce((chunks, routeManifest2) => {
-        const { referenceCssAssets = [] } = routeManifest2;
-        const _cssChunks = referenceCssAssets.filter((asset) => (asset === null || asset === void 0 ? void 0 : asset.endsWith(".css")) && !template.includes(asset));
-        return [
-          ...chunks,
-          ..._cssChunks
-        ];
-      }, []) : [];
-      const { enableInlineStyles } = config;
-      const styles = await Promise.all(cssChunks.map(async (chunk) => {
-        const link = `<link href="${chunk}" rel="stylesheet" />`;
-        if (checkIsNode() && checkIsInline(chunk, enableInlineStyles)) {
-          return readAsset(chunk).then((content) => `<style>${content}</style>`).catch((_) => {
-            return link;
-          });
-        } else {
-          return link;
-        }
-      }));
-      return `${styles.join("")}`;
-    }
-  }
-}
-export {
-  buildShellBeforeTemplate
-};

package/dist/esm-node/core/server/stream/createReadableStream.js

@@ -1,123 +0,0 @@
-import { PassThrough, Transform } from "stream";
-import { createReadableStreamFromReadable, storage } from "@modern-js/runtime-utils/node";
-import checkIsBot from "isbot";
-import { ServerStyleSheet } from "styled-components";
-import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
-import { RenderLevel } from "../../constants";
-import { getMonitors } from "../../context/monitors";
-import { enqueueFromEntries } from "./deferredScript";
-import { ShellChunkStatus, getReadableStreamFromString } from "./shared";
-import { getTemplates } from "./template";
-const createReadableStreamFromElement = async (request, rootElement, options) => {
-  const { renderToPipeableStream } = await import("react-dom/server");
-  const { runtimeContext, htmlTemplate, config, ssrConfig, entryName } = options;
-  let shellChunkStatus = ShellChunkStatus.START;
-  let renderLevel = RenderLevel.SERVER_RENDER;
-  const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
-  const isbot = checkIsBot(request.headers.get("user-agent"));
-  const onReady = isbot || forceStream2String ? "onAllReady" : "onShellReady";
-  const sheet = new ServerStyleSheet();
-  const chunkVec = [];
-  const root = sheet.collectStyles(rootElement);
-  return new Promise((resolve) => {
-    const { pipe: reactStreamingPipe } = 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);
-        getTemplates(htmlTemplate, {
-          request,
-          ssrConfig,
-          renderLevel,
-          runtimeContext,
-          config,
-          entryName,
-          styledComponentsStyleTags
-        }).then(({ shellAfter, shellBefore }) => {
-          const pendingScripts = [];
-          const body = new Transform({
-            transform(chunk, _encoding, callback) {
-              try {
-                if (shellChunkStatus !== ShellChunkStatus.FINISH) {
-                  chunkVec.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                  const chunkStr = chunk.toString("utf-8");
-                  if (chunkStr.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
-                    let concatedChunk = Buffer.concat(chunkVec).toString("utf-8");
-                    concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                    shellChunkStatus = ShellChunkStatus.FINISH;
-                    this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
-                    if (pendingScripts.length > 0) {
-                      for (const s of pendingScripts) {
-                        this.push(s);
-                      }
-                    }
-                  }
-                } else {
-                  this.push(chunk);
-                }
-                callback();
-              } catch (e) {
-                if (e instanceof Error) {
-                  callback(e);
-                } else {
-                  callback(new Error("Received unkown error when streaming"));
-                }
-              }
-            }
-          });
-          const stream = createReadableStreamFromReadable(body);
-          resolve(stream);
-          const passThrough = new PassThrough();
-          const styledStream = sheet.interleaveWithNodeStream(passThrough);
-          reactStreamingPipe(passThrough);
-          styledStream.pipe(body);
-          try {
-            var _storage_useContext, _options_runtimeContext, _storageContext_activeDeferreds;
-            const storageContext = (_storage_useContext = storage.useContext) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.call(storage);
-            const routerContext = (_options_runtimeContext = options.runtimeContext) === null || _options_runtimeContext === void 0 ? void 0 : _options_runtimeContext.routerContext;
-            const entries = (storageContext === null || storageContext === void 0 ? void 0 : storageContext.activeDeferreds) instanceof Map && ((_storageContext_activeDeferreds = storageContext.activeDeferreds) === null || _storageContext_activeDeferreds === void 0 ? void 0 : _storageContext_activeDeferreds.size) > 0 ? Array.from(storageContext.activeDeferreds.entries()) : (routerContext === null || routerContext === void 0 ? void 0 : routerContext.activeDeferreds) ? Object.entries(routerContext.activeDeferreds) : [];
-            if (entries.length > 0) {
-              const enqueueScript = (s) => {
-                if (shellChunkStatus === ShellChunkStatus.FINISH) {
-                  body.write(s);
-                } else {
-                  pendingScripts.push(s);
-                }
-              };
-              enqueueFromEntries(entries, config.nonce, (s) => enqueueScript(s));
-            }
-          } catch (err) {
-            const monitors = getMonitors();
-            monitors.error("cannot inject router data script", err);
-          }
-        });
-      },
-      onShellError(error) {
-        renderLevel = RenderLevel.CLIENT_RENDER;
-        getTemplates(htmlTemplate, {
-          request,
-          ssrConfig,
-          renderLevel,
-          runtimeContext,
-          entryName,
-          config
-        }).then(({ shellAfter, shellBefore }) => {
-          var _options_onShellError;
-          const fallbackHtml = `${shellBefore}${shellAfter}`;
-          const 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);
-        });
-      },
-      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);
-      }
-    });
-  });
-};
-export {
-  createReadableStreamFromElement
-};

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

@@ -1,134 +0,0 @@
-import { renderSSRStream } from "@modern-js/render/ssr";
-import { storage } from "@modern-js/runtime-utils/node";
-import checkIsBot from "isbot";
-import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
-import { RenderLevel } from "../../constants";
-import { enqueueFromEntries } from "./deferredScript";
-import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString } from "./shared";
-import { getTemplates } from "./template";
-const createReadableStreamFromElement = async (request, rootElement, options) => {
-  let shellChunkStatus = ShellChunkStatus.START;
-  const chunkVec = [];
-  const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, rscRoot } = options;
-  const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
-    renderLevel: RenderLevel.SERVER_RENDER,
-    runtimeContext,
-    ssrConfig,
-    request,
-    config,
-    entryName
-  });
-  try {
-    var _options_onShellReady;
-    const readableOriginal = await renderSSRStream(rootElement, {
-      request,
-      clientManifest: options.rscClientManifest,
-      ssrManifest: options.rscSSRManifest,
-      nonce: config.nonce,
-      rscRoot,
-      onError(error) {
-        var _options_onError;
-        (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
-      }
-    });
-    (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
-    readableOriginal.allReady.then(() => {
-      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);
-    });
-    const isbot = checkIsBot(request.headers.get("user-agent"));
-    if (isbot) {
-      await readableOriginal.allReady;
-    }
-    const reader = readableOriginal.getReader();
-    const stream = new ReadableStream({
-      start(controller) {
-        var _storage_useContext, _options_runtimeContext, _storageContext_activeDeferreds;
-        const pendingScripts = [];
-        let isClosed = false;
-        const safeEnqueue = (chunk) => {
-          if (isClosed)
-            return;
-          try {
-            controller.enqueue(chunk);
-          } catch {
-            isClosed = true;
-          }
-        };
-        const closeController = () => {
-          if (!isClosed) {
-            isClosed = true;
-            try {
-              controller.close();
-            } catch {
-            }
-          }
-        };
-        const flushPendingScripts = () => {
-          for (const s of pendingScripts) {
-            safeEnqueue(encodeForWebStream(s));
-          }
-          pendingScripts.length = 0;
-        };
-        const enqueueScript = (script) => {
-          if (shellChunkStatus === ShellChunkStatus.FINISH) {
-            safeEnqueue(encodeForWebStream(script));
-          } else {
-            pendingScripts.push(script);
-          }
-        };
-        const storageContext = (_storage_useContext = storage.useContext) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.call(storage);
-        const routerContext = (_options_runtimeContext = options.runtimeContext) === null || _options_runtimeContext === void 0 ? void 0 : _options_runtimeContext.routerContext;
-        const entries = (storageContext === null || storageContext === void 0 ? void 0 : storageContext.activeDeferreds) instanceof Map && ((_storageContext_activeDeferreds = storageContext.activeDeferreds) === null || _storageContext_activeDeferreds === void 0 ? void 0 : _storageContext_activeDeferreds.size) > 0 ? Array.from(storageContext.activeDeferreds.entries()) : (routerContext === null || routerContext === void 0 ? void 0 : routerContext.activeDeferreds) ? Object.entries(routerContext.activeDeferreds) : [];
-        if (entries.length > 0) {
-          enqueueFromEntries(entries, config.nonce, enqueueScript);
-        }
-        async function push() {
-          try {
-            const { done, value } = await reader.read();
-            if (done) {
-              closeController();
-              return;
-            }
-            if (isClosed)
-              return;
-            if (shellChunkStatus !== ShellChunkStatus.FINISH) {
-              chunkVec.push(new TextDecoder().decode(value));
-              const concatedChunk = chunkVec.join("");
-              if (concatedChunk.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
-                shellChunkStatus = ShellChunkStatus.FINISH;
-                safeEnqueue(encodeForWebStream(`${shellBefore}${concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "")}${shellAfter}`));
-                flushPendingScripts();
-              }
-            } else {
-              safeEnqueue(value);
-            }
-            if (!isClosed)
-              push();
-          } catch (error) {
-            if (!isClosed) {
-              isClosed = true;
-              try {
-                controller.error(error);
-              } catch {
-              }
-            }
-          }
-        }
-        push();
-      },
-      cancel(reason) {
-        reader.cancel(reason).catch(() => {
-        });
-      }
-    });
-    return stream;
-  } catch (e) {
-    const fallbackHtml = `${shellBefore}${shellAfter}`;
-    const stream = getReadableStreamFromString(fallbackHtml);
-    return stream;
-  }
-};
-export {
-  createReadableStreamFromElement
-};

package/dist/esm-node/core/server/stream/deferredScript.js

@@ -1,76 +0,0 @@
-import { runRouterDataFnStr } from "../../../router/runtime/constants";
-const HTML_ESCAPE_MAP = {
-  "&": "&",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&#39;"
-};
-function escapeAttr(value) {
-  return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPE_MAP[ch]);
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null;
-}
-function isDeferredDataLike(v) {
-  if (!isRecord(v))
-    return false;
-  const hasPending = "pendingKeys" in v && Array.isArray(v.pendingKeys);
-  const hasData = "data" in v && isRecord(v.data);
-  return hasPending && hasData;
-}
-function isPromiseLike(value) {
-  return !!value && typeof value.then === "function";
-}
-function toErrorInfo(error) {
-  if (error && typeof error === "object") {
-    const maybeMsg = error.message;
-    const maybeStack = error.stack;
-    return {
-      message: typeof maybeMsg === "string" ? maybeMsg : String(maybeMsg !== null && maybeMsg !== void 0 ? maybeMsg : error),
-      stack: process.env.NODE_ENV !== "production" ? maybeStack : void 0
-    };
-  }
-  return {
-    message: String(error)
-  };
-}
-function buildDeferredDataScript(nonce, args) {
-  const payload = JSON.stringify(args);
-  const escaped = escapeAttr(payload);
-  const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
-  return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${runRouterDataFnStr}</script>`;
-}
-function enqueueFromEntries(entries, nonce, emit) {
-  entries.forEach(([routeId, value]) => {
-    if (!isDeferredDataLike(value))
-      return;
-    var _value_pendingKeys;
-    const pendingKeys = new Set((_value_pendingKeys = value.pendingKeys) !== null && _value_pendingKeys !== void 0 ? _value_pendingKeys : []);
-    pendingKeys.forEach((key) => {
-      var _value_data;
-      const tracked = (_value_data = value.data) === null || _value_data === void 0 ? void 0 : _value_data[key];
-      if (isPromiseLike(tracked)) {
-        tracked.then((val) => emit(buildDeferredDataScript(nonce, [
-          routeId,
-          key,
-          val
-        ])), (err) => emit(buildDeferredDataScript(nonce, [
-          routeId,
-          key,
-          void 0,
-          toErrorInfo(err)
-        ])));
-      }
-    });
-  });
-}
-export {
-  buildDeferredDataScript,
-  enqueueFromEntries,
-  escapeAttr,
-  isDeferredDataLike,
-  isPromiseLike,
-  isRecord,
-  toErrorInfo
-};

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

@@ -1,6 +0,0 @@
-import { createRenderStreaming } from "./shared";
-const createReadableStreamFromElement = process.env.MODERN_SSR_ENV === "edge" ? import("./createReadableStream.worker").then((m) => m.createReadableStreamFromElement) : import("./createReadableStream").then((m) => m.createReadableStreamFromElement);
-const renderStreaming = createRenderStreaming(createReadableStreamFromElement);
-export {
-  renderStreaming
-};

package/dist/esm-node/core/server/stream/shared.js

@@ -1,86 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { time } from "@modern-js/runtime-utils/time";
-import { JSX_SHELL_STREAM_END_MARK } from "../../../common";
-import { wrapRuntimeContextProvider } from "../../react/wrapper";
-import { SSRErrors, SSRTimings } from "../tracer";
-import { getSSRConfigByEntry } from "../utils";
-var ShellChunkStatus;
-(function(ShellChunkStatus2) {
-  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
-  ShellChunkStatus2[ShellChunkStatus2["FINISH"] = 1] = "FINISH";
-})(ShellChunkStatus || (ShellChunkStatus = {}));
-let encoder;
-function encodeForWebStream(thing) {
-  if (!encoder) {
-    encoder = new TextEncoder();
-  }
-  if (typeof thing === "string") {
-    return encoder.encode(thing);
-  }
-  return thing;
-}
-function getReadableStreamFromString(content) {
-  const readableStream = new ReadableStream({
-    start(controller) {
-      controller.enqueue(encodeForWebStream(content));
-      controller.close();
-    }
-  });
-  return readableStream;
-}
-function createRenderStreaming(createReadableStreamPromise) {
-  return async (request, serverRoot, options) => {
-    const createReadableStreamFromElement = await createReadableStreamPromise;
-    const end = time();
-    const { runtimeContext, config, resource } = options;
-    const { onError, onTiming } = options;
-    const { htmlTemplate, entryName } = resource;
-    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-    const StreamServerRootWrapper = ({ children }) => {
-      return /* @__PURE__ */ _jsxs(_Fragment, {
-        children: [
-          children,
-          JSX_SHELL_STREAM_END_MARK
-        ]
-      });
-    };
-    let rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
-      ssr: true
-    }));
-    rootElement = /* @__PURE__ */ _jsx(StreamServerRootWrapper, {
-      children: rootElement
-    });
-    const stream = await createReadableStreamFromElement(request, rootElement, {
-      config,
-      htmlTemplate,
-      runtimeContext,
-      ssrConfig,
-      entryName,
-      rscClientManifest: options.rscClientManifest,
-      rscSSRManifest: options.rscSSRManifest,
-      rscServerManifest: options.rscServerManifest,
-      rscRoot: options.rscRoot,
-      onShellReady() {
-        const cost = end();
-        onTiming(SSRTimings.RENDER_SHELL, cost);
-      },
-      onAllReady() {
-        const cost = end();
-        onTiming(SSRTimings.RENDER_HTML, cost);
-      },
-      onShellError(error) {
-        onError(error, SSRErrors.RENDER_SHELL);
-      },
-      onError(error) {
-        onError(error, SSRErrors.RENDER_STREAM);
-      }
-    });
-    return stream;
-  };
-}
-export {
-  ShellChunkStatus,
-  createRenderStreaming,
-  encodeForWebStream,
-  getReadableStreamFromString
-};

package/dist/esm-node/core/server/stream/template.js

@@ -1,15 +0,0 @@
-import { buildShellAfterTemplate } from "./afterTemplate";
-import { buildShellBeforeTemplate } from "./beforeTemplate";
-const HTML_SEPARATOR = "<!--<?- html ?>-->";
-const getTemplates = async (htmlTemplate, options) => {
-  const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = htmlTemplate.split(HTML_SEPARATOR) || [];
-  const builtBeforeTemplate = await buildShellBeforeTemplate(beforeAppTemplate, options);
-  const builtAfterTemplate = await buildShellAfterTemplate(afterAppHtmlTemplate, options);
-  return {
-    shellBefore: builtBeforeTemplate,
-    shellAfter: builtAfterTemplate
-  };
-};
-export {
-  getTemplates
-};

package/dist/esm-node/core/server/string/index.js

@@ -1,113 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import ReactDomServer from "react-dom/server";
-import ReactHelmet from "react-helmet";
-import { RenderLevel } from "../../constants";
-import { wrapRuntimeContextProvider } from "../../react/wrapper";
-import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants";
-import { createReplaceHelemt } from "../helmet";
-import { buildHtml } from "../shared";
-import { SSRErrors, SSRTimings } from "../tracer";
-import { getSSRConfigByEntry, safeReplace } from "../utils";
-import { LoadableCollector } from "./loadable";
-import { prefetch } from "./prefetch";
-import { SSRDataCollector } from "./ssrData";
-import { StyledCollector } from "./styledComponent";
-const renderString = async (request, serverRoot, options) => {
-  var _runtimeContext_ssrContext;
-  const { resource, runtimeContext, config, onError, onTiming } = options;
-  const tracer = {
-    onError,
-    onTiming
-  };
-  const routerContext = runtimeContext.routerContext;
-  const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
-  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-  const chunkSet = {
-    renderLevel: RenderLevel.CLIENT_RENDER,
-    ssrScripts: "",
-    jsChunk: "",
-    cssChunk: ""
-  };
-  let prefetchData = {};
-  try {
-    prefetchData = await prefetch(serverRoot, request, options, ssrConfig, tracer);
-    chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
-  } catch (e) {
-    chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
-    tracer.onError(e, SSRErrors.PRERENDER);
-  }
-  const collectors = [
-    new StyledCollector(chunkSet),
-    new LoadableCollector({
-      stats: loadableStats,
-      nonce: config.nonce,
-      routeManifest,
-      template: htmlTemplate,
-      entryName,
-      chunkSet,
-      config
-    }),
-    new SSRDataCollector({
-      request,
-      prefetchData,
-      ssrConfig,
-      ssrContext: runtimeContext.ssrContext,
-      chunkSet,
-      routerContext,
-      nonce: config.nonce,
-      useJsonScript: config.useJsonScript
-    })
-  ];
-  const rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
-    ssr: true
-  }));
-  const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
-  return html;
-};
-async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
-  let html = "";
-  let helmetData;
-  const finalApp = collectors.reduce((pre, creator) => {
-    var _creator_collect;
-    return ((_creator_collect = creator.collect) === null || _creator_collect === void 0 ? void 0 : _creator_collect.call(creator, pre)) || pre;
-  }, App);
-  try {
-    const end = time();
-    if (chunkSet.renderLevel >= RenderLevel.SERVER_PREFETCH) {
-      html = ReactDomServer.renderToString(finalApp);
-      chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
-    }
-    helmetData = ReactHelmet.renderStatic();
-    const cost = end();
-    onTiming(SSRTimings.RENDER_HTML, cost);
-  } catch (e) {
-    chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
-    onError(e, SSRErrors.RENDER_HTML);
-  }
-  await Promise.all(collectors.map((component) => component.effect()));
-  const { ssrScripts, cssChunk, jsChunk } = chunkSet;
-  const finalHtml = await buildHtml(htmlTemplate, [
-    createReplaceHtml(html),
-    createReplaceChunkJs(jsChunk),
-    createReplaceChunkCss(cssChunk),
-    createReplaceSSRDataScript(ssrScripts),
-    createReplaceHelemt(helmetData),
-    ...htmlModifiers
-  ]);
-  return finalHtml;
-}
-function createReplaceHtml(html) {
-  return (template) => safeReplace(template, HTML_PLACEHOLDER, html);
-}
-function createReplaceSSRDataScript(data) {
-  return (template) => safeReplace(template, SSR_DATA_PLACEHOLDER, data);
-}
-function createReplaceChunkJs(js) {
-  return (template) => safeReplace(template, CHUNK_JS_PLACEHOLDER, js);
-}
-function createReplaceChunkCss(css) {
-  return (template) => safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
-}
-export {
-  renderString
-};