@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

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

@@ -1,199 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { storage } from "@modern-js/runtime-utils/node";
-import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
-import { Fragment } from "react";
-import { getGlobalAppInit, getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context";
-import { getInitialContext } from "../context/runtime";
-import { getServerPayload } from "../context/serverPayload/index";
-import { createLoaderManager } from "../loader/loaderManager";
-import { createRoot } from "../react";
-import { CHUNK_CSS_PLACEHOLDER } from "./constants";
-import { SSRErrors } from "./tracer";
-import { getSSRConfigByEntry, getSSRMode } from "./utils";
-async function handleRSCRequest(request, Root, context, options, handleRequest) {
-  const serverPayload = getServerPayload();
-  if (typeof serverPayload !== "undefined") {
-    return await handleRequest(request, Root, {
-      ...options,
-      runtimeContext: context,
-      rscRoot: serverPayload
-    });
-  }
-  const App = getGlobalRSCRoot();
-  if (App) {
-    return await handleRequest(request, Fragment, {
-      ...options,
-      runtimeContext: context,
-      rscRoot: /* @__PURE__ */ _jsx(App, {})
-    });
-  }
-  return await handleRequest(request, Root, {
-    ...options,
-    runtimeContext: context
-  });
-}
-function createSSRContext(request, options) {
-  const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, logger, metrics, reporter } = options;
-  const { nonce, useJsonScript } = config;
-  const { entryName, route } = resource;
-  const { headers } = request;
-  const cookie = headers.get("cookie") || "";
-  const cookieMap = parseCookie(request);
-  const pathname = getPathname(request);
-  const query = parseQuery(request);
-  const headersData = parseHeaders(request);
-  const url = new URL(request.url);
-  const host = headers.get("X-Forwarded-Host") || headers.get("host") || url.host;
-  let protocol = (headers.get("X-Forwarded-Proto") || url.protocol || "http").split(/\s*,\s*/, 1)[0];
-  if (!protocol.endsWith(":")) {
-    protocol += ":";
-  }
-  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-  const ssrMode = getSSRMode(ssrConfig);
-  const loaderFailureMode = typeof ssrConfig === "object" ? ssrConfig.loaderFailureMode : void 0;
-  return {
-    nonce,
-    useJsonScript,
-    loaderContext,
-    redirection: {},
-    htmlModifiers: [],
-    logger,
-    metrics,
-    request: {
-      url: request.url.replace(url.host, host).replace(url.protocol, protocol),
-      baseUrl: route.urlPath,
-      userAgent: headers.get("user-agent"),
-      cookie,
-      cookieMap,
-      pathname,
-      query,
-      params,
-      headers: headersData,
-      host,
-      referer: headers.get("referer"),
-      raw: request
-    },
-    response: {
-      setHeader(key, value) {
-        responseProxy.headers[key] = value;
-      },
-      status(code) {
-        responseProxy.status = code;
-      },
-      locals: locals || {}
-    },
-    reporter,
-    mode: ssrMode,
-    onError,
-    onTiming,
-    loaderFailureMode
-  };
-}
-const createRequestHandler = async (handleRequest, createRequestOptions) => {
-  const requestHandler = async (request, options) => {
-    const headersData = parseHeaders(request);
-    const responseProxy = {
-      headers: {},
-      status: -1
-    };
-    const activeDeferreds = /* @__PURE__ */ new Map();
-    return storage.run({
-      headers: headersData,
-      request,
-      monitors: options.monitors,
-      responseProxy,
-      activeDeferreds,
-      serverPayload: void 0
-    }, async () => {
-      var _context_routerContext, _context_routerContext1, _context_routerContext2;
-      const Root = createRoot();
-      const internalRuntimeContext = getGlobalInternalRuntimeContext();
-      const hooks = internalRuntimeContext.hooks;
-      const { routeManifest } = options.resource;
-      const context = getInitialContext(false, routeManifest);
-      const runBeforeRender = async (context2) => {
-        const result = await hooks.onBeforeRender.call(context2);
-        if (typeof Response !== "undefined" && result instanceof Response) {
-          return result;
-        }
-        const init = getGlobalAppInit();
-        return init === null || init === void 0 ? void 0 : init(context2);
-      };
-      const ssrContext = createSSRContext(request, {
-        ...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
-        })
-      });
-      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 runBeforeRender(context);
-      if (((_context_routerContext = context.routerContext) === null || _context_routerContext === void 0 ? void 0 : _context_routerContext.statusCode) && ((_context_routerContext1 = context.routerContext) === null || _context_routerContext1 === void 0 ? void 0 : _context_routerContext1.statusCode) !== 200) {
-        var _context_routerContext3, _context_ssrContext;
-        (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.response.status((_context_routerContext3 = context.routerContext) === null || _context_routerContext3 === void 0 ? void 0 : _context_routerContext3.statusCode);
-      }
-      const errors = Object.values(((_context_routerContext2 = context.routerContext) === null || _context_routerContext2 === void 0 ? void 0 : _context_routerContext2.errors) || {});
-      if (errors.length > 0) {
-        options.onError(errors[0], SSRErrors.LOADER_ERROR);
-      }
-      context.initialData = initialData;
-      const redirectResponse = getRedirectResponse(initialData);
-      if (redirectResponse) {
-        if (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) {
-          return initialData;
-        } else {
-          return redirectResponse;
-        }
-      }
-      if (!(createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc)) {
-        const { htmlTemplate } = options.resource;
-        options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${CHUNK_CSS_PLACEHOLDER}</head>`);
-      }
-      let response;
-      if (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) {
-        response = await handleRSCRequest(request, Root, context, options, handleRequest);
-      } else {
-        response = await handleRequest(request, Root, {
-          ...options,
-          runtimeContext: context
-        });
-      }
-      Object.entries(responseProxy.headers).forEach(([key, value]) => {
-        response.headers.set(key, value);
-      });
-      if (responseProxy.status !== -1) {
-        return new Response(response.body, {
-          status: responseProxy.status,
-          headers: response.headers
-        });
-      }
-      return response;
-    });
-  };
-  return requestHandler;
-};
-export {
-  createRequestHandler
-};

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

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

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

@@ -1,76 +0,0 @@
-import { serializeJson } from "@modern-js/runtime-utils/node";
-import { SSR_DATA_JSON_ID } from "../../constants";
-import { SSR_DATA_PLACEHOLDER } from "../constants";
-import { buildHtml } from "../shared";
-import { attributesToString, safeReplace } from "../utils";
-function buildShellAfterTemplate(afterAppTemplate, options) {
-  const { request, config, ssrConfig, runtimeContext, renderLevel, entryName } = options;
-  const callbacks = [
-    createReplaceSSRData({
-      request,
-      ssrConfig,
-      nonce: config.nonce,
-      useJsonScript: config.useJsonScript,
-      runtimeContext,
-      renderLevel
-    }),
-    (template) => injectJs(template, entryName, config.nonce)
-  ];
-  async function injectJs(template, entryName2, nonce) {
-    const { routeManifest } = runtimeContext;
-    const { routeAssets } = routeManifest;
-    if (!routeAssets)
-      return template;
-    const asyncEntry = routeAssets[`async-${entryName2}`];
-    if (asyncEntry) {
-      var _assets_filter;
-      const { assets } = asyncEntry;
-      const jsChunkStr = assets === null || assets === void 0 ? void 0 : (_assets_filter = assets.filter((asset) => asset.endsWith(".js"))) === null || _assets_filter === void 0 ? void 0 : _assets_filter.map((asset) => {
-        return `<script src=${asset} nonce="${nonce}"></script>`;
-      }).join(" ");
-      if (jsChunkStr) {
-        return safeReplace(template, "<!--<?- chunksMap.js ?>-->", jsChunkStr);
-      }
-    }
-    return template;
-  }
-  return buildHtml(afterAppTemplate, callbacks);
-}
-function createReplaceSSRData(options) {
-  const { runtimeContext, nonce, renderLevel, useJsonScript, 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.url,
-        headers
-      }
-    },
-    mode: "stream",
-    renderLevel
-  };
-  const attrsStr = attributesToString({
-    nonce
-  });
-  const serializeSSRData = serializeJson(ssrData);
-  const ssrDataScript = useJsonScript ? `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
-  return (template) => safeReplace(template, SSR_DATA_PLACEHOLDER, ssrDataScript);
-}
-export {
-  buildShellAfterTemplate
-};

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
-};