@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/esm/core/context/request/index.server.mjs

@@ -0,0 +1,6 @@
+import { storage } from "@modern-js/runtime-utils/node";
+const getRequest = ()=>{
+    const context = storage.useContext();
+    return context?.request;
+};
+export { getRequest };

package/dist/esm/core/context/response/index.mjs

@@ -0,0 +1,7 @@
+const getResponseProxy = ()=>null;
+const setHeaders = (headers)=>{};
+const setStatus = (status)=>{};
+const redirect = (url, init)=>{
+    console.warn("You should not use this API in the browser, please use the router's redirect or useNavigate method.");
+};
+export { getResponseProxy, redirect, setHeaders, setStatus };

package/dist/esm/core/context/response/index.server.mjs

@@ -0,0 +1,28 @@
+import { storage } from "@modern-js/runtime-utils/node";
+const getResponseProxy = ()=>{
+    const context = storage.useContext();
+    return context?.responseProxy;
+};
+const setHeaders = (headers)=>{
+    const responseProxy = getResponseProxy();
+    Object.entries(headers).forEach(([key, value])=>{
+        responseProxy.headers[key] = value;
+    });
+};
+const setStatus = (status)=>{
+    const responseProxy = getResponseProxy();
+    responseProxy.status = status;
+};
+const redirect = (url, init)=>{
+    const status = void 0 === init ? 307 : 'number' == typeof init ? init : init.status ?? 307;
+    const headers = void 0 === init ? {} : 'number' == typeof init ? {} : init.headers ?? {};
+    setStatus(status);
+    setHeaders({
+        Location: url,
+        ...init && 'object' == typeof init ? Object.fromEntries(Object.entries(headers).map(([k, v])=>[
+                k,
+                String(v)
+            ])) : {}
+    });
+};
+export { getResponseProxy, redirect, setHeaders, setStatus };

package/dist/esm/core/context/runtime.mjs

@@ -0,0 +1,19 @@
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
+import { createContext, useContext } from "react";
+const InternalRuntimeContext = createContext({});
+const RuntimeContext = createContext({});
+const ReactRuntimeContext = RuntimeContext;
+const getInitialContext = (isBrowser = true, routeManifest)=>{
+    const requestContext = {
+        request: {},
+        response: {}
+    };
+    return {
+        isBrowser,
+        routeManifest: routeManifest || "u" > typeof window && window[ROUTE_MANIFEST],
+        requestContext,
+        context: requestContext
+    };
+};
+const useRuntimeContext = ()=>useContext(RuntimeContext);
+export { InternalRuntimeContext, ReactRuntimeContext, RuntimeContext, getInitialContext, useRuntimeContext };

package/dist/esm/core/context/serverPayload/index.mjs

@@ -0,0 +1,3 @@
+const getServerPayload = ()=>{};
+const setServerPayload = (payload)=>{};
+export { getServerPayload, setServerPayload };

package/dist/esm/core/context/serverPayload/index.server.mjs

@@ -0,0 +1,10 @@
+import { storage } from "@modern-js/runtime-utils/node";
+const getServerPayload = ()=>{
+    const context = storage.useContext();
+    return context?.serverPayload;
+};
+const setServerPayload = (payload)=>{
+    const context = storage.useContext();
+    if (context) context.serverPayload = payload;
+};
+export { getServerPayload, setServerPayload };

package/dist/esm/core/index.mjs

@@ -0,0 +1,2 @@
+export { defineRuntimeConfig } from "./config.mjs";
+export { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";

package/dist/esm/core/plugin/index.mjs

@@ -0,0 +1,25 @@
+import { runtime } from "@modern-js/plugin/runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { compatPlugin } from "../compat/index.mjs";
+import { handleSetupResult } from "../compat/hooks.mjs";
+import { requestContextPlugin } from "../compat/requestContext.mjs";
+import { setGlobalInternalRuntimeContext } from "../context/index.mjs";
+function registerPlugin(internalPlugins, runtimeConfig) {
+    const { plugins = [] } = runtimeConfig || {};
+    const { runtimeContext } = runtime.run({
+        plugins: [
+            compatPlugin(),
+            requestContextPlugin(),
+            ...internalPlugins,
+            ...plugins
+        ],
+        config: runtimeConfig || {},
+        handleSetupResult: handleSetupResult
+    });
+    setGlobalInternalRuntimeContext(runtimeContext);
+    return runtimeContext;
+}
+function mergeConfig(config, ...otherConfig) {
+    return merge({}, config, ...otherConfig);
+}
+export { mergeConfig, registerPlugin };

package/dist/esm/core/react/index.mjs

@@ -0,0 +1,16 @@
+import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
+import { isBrowser } from "../../common.mjs";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants.mjs";
+import { getGlobalApp, getGlobalInternalRuntimeContext } from "../context/index.mjs";
+function createRoot(UserApp) {
+    const App = UserApp || getGlobalApp();
+    if (isBrowser()) {
+        window._SSR_DATA = window._SSR_DATA || parsedJSONFromElement(SSR_DATA_JSON_ID);
+        window._ROUTER_DATA = window._ROUTER_DATA || parsedJSONFromElement(ROUTER_DATA_JSON_ID);
+    }
+    const internalRuntimeContext = getGlobalInternalRuntimeContext();
+    const hooks = internalRuntimeContext.hooks;
+    const WrapperApp = hooks.wrapRoot.call(App);
+    return WrapperApp;
+}
+export { createRoot };

package/dist/esm/core/react/wrapper.mjs

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { InternalRuntimeContext, RuntimeContext } from "../context/index.mjs";
+function wrapRuntimeContextProvider(App, contextValue) {
+    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
+    const runtimeContextValue = {
+        isBrowser,
+        initialData,
+        routes,
+        routerFramework,
+        context,
+        ...rest
+    };
+    return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
+            value: runtimeContextValue,
+            children: App
+        })
+    });
+}
+export { wrapRuntimeContextProvider };

package/dist/esm/core/server/constants.mjs

@@ -0,0 +1,5 @@
+const HTML_PLACEHOLDER = '<!--<?- html ?>-->';
+const SSR_DATA_PLACEHOLDER = '<!--<?- SSRDataScript ?>-->';
+const CHUNK_JS_PLACEHOLDER = '<!--<?- chunksMap.js ?>-->';
+const CHUNK_CSS_PLACEHOLDER = '<!--<?- chunksMap.css ?>-->';
+export { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER };

package/dist/esm/core/server/helmet.mjs

@@ -0,0 +1,38 @@
+import { EOL } from "os";
+import { safeReplace } from "./utils.mjs";
+const RE_HTML_ATTR = /<html[^>]*>/;
+const RE_BODY_ATTR = /<body[^>]*>/;
+const RE_LAST_IN_HEAD = /<\/head>/;
+const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
+const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
+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) result = safeReplace(result, RE_BODY_ATTR, `<body ${bodyAttributes}>`);
+    const htmlAttributes = helmetData.htmlAttributes.toString();
+    if (htmlAttributes) result = safeReplace(result, RE_HTML_ATTR, `<html ${htmlAttributes}>`);
+    const base = helmetData.base.toString();
+    const link = helmetData.link.toString();
+    const meta = helmetData.meta.toString();
+    const noscript = helmetData.noscript.toString();
+    const script = helmetData.script.toString();
+    const style = helmetData.style.toString();
+    const title = helmetData.title.toString();
+    const existTitleTag = RE_TITLE.test(content);
+    const shouldReplaceTitle = existTitleTag && TEST_TITLE_CONTENT.test(title.trim());
+    if (shouldReplaceTitle) result = safeReplace(result, RE_TITLE, title);
+    const helmetStr = [
+        base,
+        link,
+        meta,
+        noscript,
+        script,
+        style,
+        !existTitleTag ? title : ''
+    ].reduce((pre, cur)=>pre + (cur.length > 0 ? `  ${cur}${EOL}` : ''), '');
+    return safeReplace(result, RE_LAST_IN_HEAD, `${helmetStr}</head>`);
+}
+export { createReplaceHelemt, helmetReplace };

package/dist/esm/core/server/index.mjs

@@ -0,0 +1,8 @@
+const ssr = (_config)=>({
+        name: '@modern-js/plugin-ssr',
+        setup: (_api)=>{}
+    });
+const server = ssr;
+export { NoSSR, NoSSRCache } from "./react/index.mjs";
+export default server;
+export { ssr };

package/dist/esm/core/server/react/index.mjs

@@ -0,0 +1,2 @@
+export { NoSSRCache } from "./no-ssr-cache/index.mjs";
+export { NoSSR } from "./nossr/index.mjs";

package/dist/esm/core/server/react/no-ssr-cache/index.mjs

@@ -0,0 +1,9 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { Helmet } from "../../../../exports/head.mjs";
+const NoSSRCache = ()=>/*#__PURE__*/ jsx(Helmet, {
+        children: /*#__PURE__*/ jsx("meta", {
+            name: "no-ssr-cache"
+        })
+    });
+export { NoSSRCache };

package/dist/esm/core/server/react/nossr/index.mjs

@@ -0,0 +1,10 @@
+import react, { useEffect, useState } from "react";
+const NoSSR = (props)=>{
+    const [isMounted, setMounted] = useState(false);
+    useEffect(()=>{
+        setMounted(true);
+    }, []);
+    const { children, fallback = null } = props || {};
+    return react.createElement(react.Fragment, null, isMounted ? children : fallback);
+};
+export { NoSSR };

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

@@ -0,0 +1,174 @@
+import { 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 react, { Fragment } from "react";
+import { cleanupRouterRuntimeState } from "../../router/runtime/lifecycle.mjs";
+import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
+import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
+import { getInitialContext } from "../context/runtime.mjs";
+import { getServerPayload } from "../context/serverPayload/index.mjs";
+import { createRoot } from "../react/index.mjs";
+import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";
+import { SSRErrors } from "./tracer.mjs";
+import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
+async function handleRSCRequest(request, Root, context, options, handleRequest) {
+    const serverPayload = getServerPayload();
+    if (void 0 !== serverPayload) 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
+    });
+}
+const isRedirectStatus = (status)=>status >= 300 && status <= 399;
+const processRedirect = (headers, status, ctx)=>{
+    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        headers
+    });
+};
+function createSSRContext(request, options) {
+    const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, 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);
+    let ssrMode = getSSRMode(ssrConfig);
+    const isSsgRender = 'true' === headers.get('x-modern-ssg-render');
+    if (isSsgRender) {
+        const reactMajor = Number((react.version || '0').split('.')[0]);
+        ssrMode = reactMajor >= 18 ? 'stream' : 'string';
+    }
+    const loaderFailureMode = 'object' == typeof ssrConfig && ssrConfig && 'loaderFailureMode' in ssrConfig ? ssrConfig.loaderFailureMode : void 0;
+    return {
+        nonce,
+        useJsonScript,
+        loaderContext,
+        htmlModifiers: [],
+        baseUrl: route.urlPath,
+        request: {
+            url: request.url.replace(url.host, host).replace(url.protocol, protocol),
+            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 = new Map();
+        return storage.run({
+            headers: headersData,
+            request,
+            monitors: options.monitors,
+            responseProxy,
+            activeDeferreds,
+            serverPayload: void 0
+        }, async ()=>{
+            const Root = createRoot();
+            const internalRuntimeContext = getGlobalInternalRuntimeContext();
+            const hooks = internalRuntimeContext.hooks;
+            const { routeManifest } = options.resource;
+            const context = getInitialContext(false, routeManifest);
+            const runBeforeRender = async (context)=>{
+                const result = await hooks.onBeforeRender.call(context);
+                if ("u" > typeof Response && result instanceof Response) return result;
+            };
+            const ssrContext = createSSRContext(request, {
+                ...options,
+                responseProxy
+            });
+            Object.assign(context, {
+                ssrContext,
+                isBrowser: false
+            });
+            const redirectCtx = {
+                enableRsc: !!createRequestOptions?.enableRsc,
+                isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
+                basename: ssrContext.baseUrl || '/'
+            };
+            try {
+                const beforeRenderResult = await runBeforeRender(context);
+                const routerServerSnapshot = context.routerServerSnapshot;
+                const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
+                if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+                const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
+                if (errors.length > 0) options.onError(errors[0], SSRErrors.LOADER_ERROR);
+                if ("u" > typeof Response && beforeRenderResult instanceof Response && isRedirectStatus(beforeRenderResult.status)) {
+                    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+                    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
+                    return processRedirect(new Headers({
+                        Location: redirectUrl
+                    }), beforeRenderResult.status, redirectCtx);
+                }
+                if (!createRequestOptions?.enableRsc) {
+                    const { htmlTemplate } = options.resource;
+                    options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
+                }
+                let response;
+                response = createRequestOptions?.enableRsc ? await handleRSCRequest(request, Root, context, options, handleRequest) : await handleRequest(request, Root, {
+                    ...options,
+                    runtimeContext: context
+                });
+                if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
+                Object.entries(responseProxy.headers).forEach(([key, value])=>{
+                    response.headers.set(key, value);
+                });
+                if (-1 !== responseProxy.status) return new Response(response.body, {
+                    status: responseProxy.status,
+                    headers: response.headers
+                });
+                return response;
+            } finally{
+                await cleanupRouterRuntimeState(context);
+            }
+        });
+    };
+    return requestHandler;
+};
+export { createRequestHandler };

package/dist/esm/core/server/server.mjs

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

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

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

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

@@ -0,0 +1,69 @@
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
+import { SSR_DATA_JSON_ID } from "../../constants.mjs";
+import { SSR_DATA_PLACEHOLDER } from "../constants.mjs";
+import { buildHtml } from "../shared.mjs";
+import { attributesToString, safeReplace } from "../utils.mjs";
+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, entryName, nonce) {
+        const { routeManifest } = runtimeContext;
+        if (!routeManifest) return template;
+        const { routeAssets } = routeManifest;
+        if (!routeAssets) return template;
+        const asyncEntry = routeAssets[`async-${entryName}`];
+        if (asyncEntry) {
+            const { assets } = asyncEntry;
+            const jsChunkStr = assets?.filter((asset)=>asset.endsWith('.js'))?.map((asset)=>`<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 = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
+    const ssrData = {
+        data: {
+            initialData: runtimeContext.initialData,
+            i18nData: runtimeContext.__i18nData__
+        },
+        context: {
+            reporter: {
+                sessionId: reporter?.sessionId
+            },
+            request: {
+                query: request.query,
+                params: request.params,
+                pathname: request.pathname,
+                host: request.host,
+                url: request.url,
+                headers: 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>`;
+    const hydrationScripts = getRouterHydrationScripts(runtimeContext);
+    const ssrScripts = hydrationScripts.length ? `${ssrDataScript}\n${hydrationScripts.join('\n')}` : ssrDataScript;
+    return (template)=>safeReplace(template, SSR_DATA_PLACEHOLDER, ssrScripts);
+}
+export { buildShellAfterTemplate };

package/dist/esm/core/server/stream/beforeTemplate.mjs

@@ -0,0 +1,67 @@
+import { matchRoutes } from "@modern-js/runtime-utils/router";
+import react_helmet from "react-helmet";
+import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
+import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
+import { createReplaceHelemt } from "../helmet.mjs";
+import { buildHtml } from "../shared.mjs";
+import { checkIsNode, safeReplace } from "../utils.mjs";
+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 ('production' !== process.env.NODE_ENV) return false;
+    if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    return Boolean(enableInline);
+};
+async function buildShellBeforeTemplate(beforeAppTemplate, options) {
+    const { config, runtimeContext, styledComponentsStyleTags, entryName } = options;
+    const helmetData = react_helmet.renderStatic();
+    const callbacks = [
+        createReplaceHelemt(helmetData),
+        (template)=>injectCss(template, entryName, styledComponentsStyleTags)
+    ];
+    return buildHtml(beforeAppTemplate, callbacks);
+    async function injectCss(template, entryName, styledComponentsStyleTags) {
+        let css = await getCssChunks();
+        if (styledComponentsStyleTags) css += styledComponentsStyleTags;
+        return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+        async function getCssChunks() {
+            const { routeManifest, routerContext, routes } = runtimeContext;
+            if (!routeManifest) return '';
+            const { routeAssets } = routeManifest;
+            let matchedRouteManifests;
+            const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext);
+            if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
+            else {
+                if (!routerContext || !routes) return '';
+                const matches = matchRoutes(routes, routerContext.location, routerContext.basename);
+                matchedRouteManifests = matches?.map((match, index)=>{
+                    if (!index) return;
+                    const routeId = match.route.id;
+                    if (routeId) return routeAssets[routeId];
+                }).filter(Boolean);
+            }
+            const asyncEntry = routeAssets[`async-${entryName}`];
+            if (asyncEntry) matchedRouteManifests?.push(asyncEntry);
+            const cssChunks = matchedRouteManifests ? matchedRouteManifests.reduce((chunks, routeManifest)=>{
+                const { referenceCssAssets = [] } = routeManifest;
+                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !template.includes(asset));
+                return [
+                    ...chunks,
+                    ..._cssChunks
+                ];
+            }, []) : [];
+            const { inlineStyles } = config;
+            const styles = await Promise.all(cssChunks.map(async (chunk)=>{
+                const link = `<link href="${chunk}" rel="stylesheet" />`;
+                if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
+                return link;
+            }));
+            return `${styles.join('')}`;
+        }
+    }
+}
+export { buildShellBeforeTemplate };