@bleedingdev/modern-js-server-core 3.2.0-ultramodern.0

package/dist/cjs/plugins/render/render.js

@@ -0,0 +1,273 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router" (module) {
+        module.exports = require("@modern-js/runtime-utils/router");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        createRender: ()=>createRender
+    });
+    const universal_namespaceObject = require("@modern-js/utils/universal");
+    const trie_router_namespaceObject = require("hono/router/trie-router");
+    const external_constants_js_namespaceObject = require("../../constants.js");
+    const index_js_namespaceObject = require("../../utils/index.js");
+    const external_csrRscRender_js_namespaceObject = require("./csrRscRender.js");
+    const external_dataHandler_js_namespaceObject = require("./dataHandler.js");
+    const external_renderRscHandler_js_namespaceObject = require("./renderRscHandler.js");
+    const external_serverActionHandler_js_namespaceObject = require("./serverActionHandler.js");
+    const external_ssrRender_js_namespaceObject = require("./ssrRender.js");
+    const DYNAMIC_ROUTE_REG = /\/:./;
+    function getRouter(routes) {
+        const dynamicRoutes = [];
+        const normalRoutes = [];
+        routes.forEach((route)=>{
+            if (DYNAMIC_ROUTE_REG.test(route.urlPath)) dynamicRoutes.push(route);
+            else normalRoutes.push(route);
+        });
+        const finalRoutes = [
+            ...normalRoutes.sort(index_js_namespaceObject.sortRoutes),
+            ...dynamicRoutes.sort(index_js_namespaceObject.sortRoutes)
+        ];
+        const router = new trie_router_namespaceObject.TrieRouter();
+        for (const route of finalRoutes){
+            const { urlPath: originUrlPath } = route;
+            const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
+            router.add('*', urlPath, route);
+        }
+        return router;
+    }
+    function matchRoute(router, pathname, entryName) {
+        const matched = router.match('*', pathname);
+        const matchedRoutes = matched[0];
+        if (entryName && matchedRoutes.length > 1) {
+            for (const [route, params] of matchedRoutes)if (route.entryName === entryName) return [
+                route,
+                params
+            ];
+            return [
+                void 0,
+                {}
+            ];
+        }
+        {
+            const result = matchedRoutes[0];
+            if (!result) return [
+                void 0,
+                {}
+            ];
+            return [
+                result[0],
+                result[1]
+            ];
+        }
+    }
+    function getHeadersWithoutCookie(headers) {
+        const _headers = {
+            ...headers,
+            cookie: void 0
+        };
+        delete _headers.cookie;
+        return _headers;
+    }
+    async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
+        const router = getRouter(routes);
+        return async (req, { monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, contextForceCSR, reporter })=>{
+            const forMatchpathname = matchPathname ?? (0, index_js_namespaceObject.getPathname)(req);
+            const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
+            const framework = (0, universal_namespaceObject.cutNameByHyphen)(metaName || 'modern-js');
+            const fallbackHeader = `x-${framework}-ssr-fallback`;
+            let fallbackReason = null;
+            const fallbackWrapper = async (reason, error)=>{
+                fallbackReason = reason;
+                return onFallback?.(reason, error);
+            };
+            if (!routeInfo) return new Response((0, index_js_namespaceObject.createErrorHtml)(404), {
+                status: 404,
+                headers: {
+                    'content-type': 'text/html; charset=UTF-8'
+                }
+            });
+            const html = templates[(0, index_js_namespaceObject.uniqueKeyByRoute)(routeInfo)];
+            if (!html) return new Response((0, index_js_namespaceObject.createErrorHtml)(404), {
+                status: 404,
+                headers: {
+                    'content-type': 'text/html; charset=UTF-8'
+                }
+            });
+            const finalForceCSR = routeInfo.entryName ? forceCSRMap?.get(routeInfo.entryName) ?? forceCSR : forceCSR;
+            const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, finalForceCSR, nodeReq, fallbackWrapper, contextForceCSR);
+            const headerData = (0, index_js_namespaceObject.parseHeaders)(req);
+            const onError = (e, key)=>{
+                monitors?.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
+            };
+            const onTiming = (name, dur)=>{
+                monitors?.timing(name, dur, 'SSR');
+            };
+            const renderOptions = {
+                pwd,
+                html,
+                routeInfo,
+                staticGenerate: staticGenerate || false,
+                config,
+                nodeReq,
+                cacheConfig,
+                serverRoutes: routes,
+                params,
+                monitors,
+                locals,
+                rscClientManifest,
+                rscSSRManifest,
+                rscServerManifest,
+                serverManifest,
+                loaderContext: loaderContext || new Map(),
+                onError,
+                onTiming,
+                reporter
+            };
+            if (fallbackReason) renderOptions.html = injectFallbackReasonToHtml({
+                html: renderOptions.html,
+                reason: fallbackReason,
+                framework
+            });
+            let response;
+            switch(renderMode){
+                case 'data':
+                    response = await (0, external_dataHandler_js_namespaceObject.dataHandler)(req, renderOptions) || await renderHandler(req, renderOptions, 'ssr', fallbackWrapper, framework);
+                    break;
+                case 'rsc-tree':
+                    response = await (0, external_renderRscHandler_js_namespaceObject.renderRscHandler)(req, renderOptions);
+                    break;
+                case 'rsc-action':
+                    response = await (0, external_serverActionHandler_js_namespaceObject.serverActionHandler)(req, renderOptions);
+                    break;
+                case 'ssr':
+                case 'csr':
+                    response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper, framework);
+                    break;
+                default:
+                    throw new Error(`Unknown render mode: ${renderMode}`);
+            }
+            if (fallbackReason) response.headers.set(fallbackHeader, `1;reason=${fallbackReason}`);
+            return response;
+        };
+    }
+    async function renderHandler(request, options, mode, fallbackWrapper, framework) {
+        let response = null;
+        const { serverManifest } = options;
+        const ssrByRouteIds = options.config.server?.ssrByRouteIds;
+        const runtimeEnv = (0, index_js_namespaceObject.getRuntimeEnv)();
+        if (serverManifest.nestedRoutesJson && ssrByRouteIds && ssrByRouteIds?.length > 0 && 'node' === runtimeEnv) {
+            const { nestedRoutesJson } = serverManifest;
+            const routes = nestedRoutesJson?.[options.routeInfo.entryName];
+            if (routes) {
+                const { matchRoutes } = __webpack_require__("@modern-js/runtime-utils/router");
+                const url = new URL(request.url);
+                const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
+                if (matchedRoutes) {
+                    const lastMatch = matchedRoutes[matchedRoutes.length - 1];
+                    if (!lastMatch?.route?.id || !ssrByRouteIds.includes(lastMatch.route.id)) response = await csrRender(request, options);
+                } else response = await csrRender(request, options);
+            }
+        }
+        if ('ssr' !== mode || response) response = await csrRender(request, options);
+        else try {
+            response = await (0, external_ssrRender_js_namespaceObject.ssrRender)(request, options);
+        } catch (e) {
+            options.onError(e, index_js_namespaceObject.ErrorDigest.ERENDER);
+            await fallbackWrapper('error', e);
+            response = await csrRender(request, {
+                ...options,
+                html: injectFallbackReasonToHtml({
+                    html: options.html,
+                    reason: 'error',
+                    framework
+                })
+            });
+        }
+        const { routeInfo } = options;
+        applyExtendHeaders(response, routeInfo);
+        return response;
+        function applyExtendHeaders(r, route) {
+            Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+                r.headers.set(k, v);
+            });
+        }
+    }
+    async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback, contextForceCSR) {
+        const query = (0, index_js_namespaceObject.parseQuery)(req);
+        if (req.headers.get('x-rsc-action')) return 'rsc-action';
+        if (req.headers.get('x-rsc-tree')) return 'rsc-tree';
+        if (!isSSR) return 'csr';
+        {
+            if (query.__loader) return 'data';
+            const fallbackHeaderValue = req.headers.get(fallbackHeader) || nodeReq?.headers[fallbackHeader];
+            if (forceCSR && (query.csr || fallbackHeaderValue || contextForceCSR)) {
+                if (query.csr) await onFallback?.('query');
+                else {
+                    const reason = fallbackHeaderValue?.split(';')[1]?.split('=')[1];
+                    await onFallback?.(reason ? `header,${reason}` : 'header');
+                }
+                return 'csr';
+            }
+            return 'ssr';
+        }
+    }
+    function injectFallbackReasonToHtml({ html, reason, framework }) {
+        const tag = `<script id="__${framework}_ssr_fallback_reason__" type="application/json">${JSON.stringify({
+            reason
+        })}</script>`;
+        return html.replace(/<\/head>/, `${tag}</head>`);
+    }
+    async function csrRender(request, options) {
+        const { html } = options;
+        if (process.env.MODERN_DISABLE_INJECT_RSC_DATA || !options.routeInfo.isRSC) return new Response(html, {
+            status: 200,
+            headers: new Headers({
+                'content-type': 'text/html; charset=UTF-8',
+                [external_constants_js_namespaceObject.X_MODERNJS_RENDER]: 'client'
+            })
+        });
+        return (0, external_csrRscRender_js_namespaceObject.csrRscRender)(request, options);
+    }
+})();
+exports.createRender = __webpack_exports__.createRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/render/renderRscHandler.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    renderRscHandler: ()=>renderRscHandler
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_utils_js_namespaceObject = require("./utils.js");
+const renderRscHandler = async (req, options)=>{
+    const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, monitors, onError, onTiming, staticGenerate } = options;
+    const serverBundle = serverManifest?.renderBundles?.[routeInfo.entryName || constants_namespaceObject.MAIN_ENTRY_NAME];
+    const loadableStats = serverManifest.loadableStats || {};
+    const routeManifest = serverManifest.routeManifest || {};
+    const config = (0, external_utils_js_namespaceObject.createRequestHandlerConfig)(options.config);
+    const requestHandlerOptions = {
+        resource: {
+            route: routeInfo,
+            loadableStats,
+            routeManifest,
+            entryName: routeInfo.entryName || constants_namespaceObject.MAIN_ENTRY_NAME
+        },
+        config,
+        params,
+        loaderContext,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter: options.reporter
+    };
+    if (!serverBundle) return new Response('Cannot find server bundle for RSC', {
+        status: 500
+    });
+    const rscPayloadHandler = await serverBundle.rscPayloadHandler;
+    if (!rscPayloadHandler) return new Response('Cannot find request handler for RSC', {
+        status: 500
+    });
+    return rscPayloadHandler(req, requestHandlerOptions);
+};
+exports.renderRscHandler = __webpack_exports__.renderRscHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderRscHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/render/serverActionHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    serverActionHandler: ()=>serverActionHandler
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const serverActionHandler = async (req, { serverManifest, routeInfo, rscClientManifest })=>{
+    const serverBundle = serverManifest?.renderBundles?.[routeInfo.entryName || constants_namespaceObject.MAIN_ENTRY_NAME];
+    if (!serverBundle) return new Response('Cannot find server bundle for server action', {
+        status: 500
+    });
+    const { handleAction } = serverBundle;
+    if (!handleAction) return new Response('Cannot find server action handler', {
+        status: 500
+    });
+    return handleAction(req);
+};
+exports.serverActionHandler = __webpack_exports__.serverActionHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "serverActionHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/render/ssrCache.js

@@ -0,0 +1,198 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getCacheResult: ()=>getCacheResult,
+    matchCacheControl: ()=>matchCacheControl,
+    shouldUseCache: ()=>shouldUseCache
+});
+const storer_namespaceObject = require("@modern-js/runtime-utils/storer");
+const external_constants_js_namespaceObject = require("../../constants.js");
+const index_js_namespaceObject = require("../../utils/index.js");
+const removeTailSlash = (s)=>s.replace(/\/+$/, '');
+const ZERO_RENDER_LEVEL = /"renderLevel":0/;
+const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
+async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
+    const response = await requestHandler(request, requestHandlerOptions);
+    const { onError } = requestHandlerOptions;
+    const nonCacheableStatusCodes = [
+        204,
+        305,
+        404,
+        405,
+        500,
+        501,
+        502,
+        503,
+        504
+    ];
+    if (nonCacheableStatusCodes.includes(response.status)) return response;
+    const decoder = new TextDecoder();
+    if (response.body) {
+        const stream = (0, index_js_namespaceObject.createTransformStream)();
+        const reader = response.body.getReader();
+        const writer = stream.writable.getWriter();
+        let html = '';
+        const push = ()=>reader.read().then(({ done, value })=>{
+                if (done) {
+                    const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
+                    if (match) return void writer.close();
+                    const current = Date.now();
+                    const cache = {
+                        val: html,
+                        cursor: current
+                    };
+                    container.set(key, JSON.stringify(cache), {
+                        ttl
+                    }).catch(()=>{
+                        if (onError) onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
+                        else console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
+                    });
+                    writer.close();
+                    return;
+                }
+                const content = decoder.decode(value);
+                html += content;
+                writer.write(value);
+                push();
+            });
+        push();
+        cacheStatus && response.headers.set(external_constants_js_namespaceObject.X_RENDER_CACHE, cacheStatus);
+        return new Response(stream.readable, {
+            status: response.status,
+            headers: response.headers
+        });
+    }
+    return response;
+}
+const CACHE_NAMESPACE = '__ssr__cache';
+const storage = (0, storer_namespaceObject.createMemoryStorage)(CACHE_NAMESPACE);
+function computedKey(req, cacheControl) {
+    const pathname = (0, index_js_namespaceObject.getPathname)(req);
+    const { customKey } = cacheControl;
+    const defaultKey = '/' === pathname ? pathname : removeTailSlash(pathname);
+    if (!customKey) return defaultKey;
+    if ('string' == typeof customKey) return customKey;
+    return customKey(defaultKey);
+}
+function shouldUseCache(request) {
+    const url = new URL(request.url);
+    const hasRSCAction = request.headers.has('x-rsc-action');
+    const hasRSCTree = request.headers.has('x-rsc-tree');
+    const hasLoaderQuery = url.searchParams.has('__loader');
+    return !(hasRSCAction || hasRSCTree || hasLoaderQuery);
+}
+function matchCacheControl(cacheOption, req) {
+    if (!cacheOption || !req) return;
+    {
+        if (isCacheControl(cacheOption)) return cacheOption;
+        if (isCacheOptionProvider(cacheOption)) return cacheOption(req);
+        const url = req.url;
+        const options = Object.entries(cacheOption);
+        for (const [key, option] of options)if ('*' === key || new RegExp(key).test(url)) if ('function' == typeof option) return option(req);
+        else return option;
+        return;
+    }
+    function isCacheOptionProvider(option) {
+        return 'function' == typeof option;
+    }
+    function isCacheControl(option) {
+        return 'object' == typeof option && null !== option && 'maxAge' in option;
+    }
+}
+async function getCacheResult(request, options) {
+    const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
+    const { onError } = requestHandlerOptions;
+    const key = computedKey(request, cacheControl);
+    let value;
+    try {
+        value = await container.get(key);
+    } catch (_) {
+        if (onError) onError(`[render-cache] get cache failed, key: ${key}`);
+        else console.error(`[render-cache] get cache failed, key: ${key}`);
+        value = void 0;
+    }
+    const { maxAge, staleWhileRevalidate } = cacheControl;
+    const ttl = maxAge + staleWhileRevalidate;
+    if (!value) return processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container,
+        cacheStatus: 'miss'
+    });
+    {
+        const cache = JSON.parse(value);
+        const interval = Date.now() - cache.cursor;
+        if (interval <= maxAge) {
+            const cacheStatus = 'hit';
+            return new Response(cache.val, {
+                headers: {
+                    [external_constants_js_namespaceObject.X_RENDER_CACHE]: cacheStatus
+                }
+            });
+        }
+        if (!(interval <= staleWhileRevalidate + maxAge)) return processCache({
+            key,
+            request,
+            requestHandler,
+            requestHandlerOptions,
+            ttl,
+            container,
+            cacheStatus: 'expired'
+        });
+        {
+            processCache({
+                key,
+                request,
+                requestHandler,
+                requestHandlerOptions,
+                ttl,
+                container
+            }).then(async (response)=>{
+                await response.text();
+            });
+            const cacheStatus = 'stale';
+            return new Response(cache.val, {
+                headers: {
+                    [external_constants_js_namespaceObject.X_RENDER_CACHE]: cacheStatus
+                }
+            });
+        }
+    }
+}
+exports.getCacheResult = __webpack_exports__.getCacheResult;
+exports.matchCacheControl = __webpack_exports__.matchCacheControl;
+exports.shouldUseCache = __webpack_exports__.shouldUseCache;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getCacheResult",
+    "matchCacheControl",
+    "shouldUseCache"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/render/ssrRender.js

@@ -0,0 +1,96 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ssrRender: ()=>ssrRender
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_constants_js_namespaceObject = require("../../constants.js");
+const index_js_namespaceObject = require("../../utils/index.js");
+const external_ssrCache_js_namespaceObject = require("./ssrCache.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const SERVER_RUNTIME_ENTRY = 'requestHandler';
+async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, monitors, cacheConfig, onError, onTiming, reporter }) {
+    const { entryName } = routeInfo;
+    const loadableStats = serverManifest.loadableStats || {};
+    const routeManifest = serverManifest.routeManifest || {};
+    const headers = (0, index_js_namespaceObject.parseHeaders)(request);
+    if (nodeReq) {
+        for(const key in nodeReq.headers)if (!headers[key]) headers[key] = nodeReq.headers[key];
+    }
+    const renderBundle = serverManifest.renderBundles?.[entryName || constants_namespaceObject.MAIN_ENTRY_NAME];
+    if (!renderBundle) throw new Error(`Can't find renderBundle ${entryName || constants_namespaceObject.MAIN_ENTRY_NAME}`);
+    const requestHandler = await renderBundle[SERVER_RUNTIME_ENTRY];
+    const config = (0, external_utils_js_namespaceObject.createRequestHandlerConfig)(userConfig);
+    const requestHandlerOptions = {
+        resource: {
+            route: routeInfo,
+            loadableStats,
+            routeManifest,
+            htmlTemplate: html,
+            entryName: entryName || constants_namespaceObject.MAIN_ENTRY_NAME
+        },
+        params,
+        loaderContext,
+        config,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter
+    };
+    const cacheControl = await (0, external_ssrCache_js_namespaceObject.matchCacheControl)(cacheConfig?.strategy, nodeReq || new IncomingMessgeProxy(request));
+    let response;
+    response = cacheControl && (0, external_ssrCache_js_namespaceObject.shouldUseCache)(request) ? await (0, external_ssrCache_js_namespaceObject.getCacheResult)(request, {
+        cacheControl,
+        container: cacheConfig?.container,
+        requestHandler: requestHandler,
+        requestHandlerOptions
+    }) : await requestHandler(request, requestHandlerOptions);
+    response.headers.set(external_constants_js_namespaceObject.X_MODERNJS_RENDER, 'server');
+    response.headers.set('content-type', 'text/html; charset=UTF-8');
+    return response;
+}
+class IncomingMessgeProxy {
+    constructor(req){
+        this.headers = {};
+        req.headers.forEach((value, key)=>{
+            this.headers[key] = value;
+        });
+        this.method = req.method;
+        this.url = (0, index_js_namespaceObject.getPathname)(req);
+    }
+}
+exports.ssrRender = __webpack_exports__.ssrRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ssrRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});