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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# Modern.js Package
+
+## Get Started
+
+Run and debug the module:
+
+```bash
+pnpm run dev
+```
+
+Run test cases:
+
+```bash
+pnpm run test
+```
+
+Build the module for production:
+
+```bash
+pnpm run build
+```
+
+Enable optional features:
+
+```bash
+pnpm run new
+```
+
+
+For more information, see the [Modern.js Module documentation](https://modernjs.dev/module-tools/en).

package/dist/cjs/apply.js

@@ -0,0 +1,97 @@
+"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__, {
+    applyPlugins: ()=>applyPlugins
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const node_namespaceObject = require("@modern-js/server-core/node");
+const utils_namespaceObject = require("@modern-js/utils");
+function getLogger(_) {
+    if (process.env.DEBUG || 'production' === process.env.NODE_ENV) return (0, utils_namespaceObject.createLogger)({
+        level: process.env.MODERN_SERVER_LOG_LEVEL || 'verbose'
+    });
+    return (0, utils_namespaceObject.createLogger)();
+}
+async function applyPlugins(serverBase, options, nodeServer) {
+    const { pwd, appContext, config, logger: optLogger, serverConfig } = options;
+    const enableRsc = config.server?.rsc ?? serverConfig?.server?.rsc ?? false;
+    const serverErrorHandler = options.serverConfig?.onError;
+    const loadCachePwd = (0, utils_namespaceObject.isProd)() ? pwd : appContext.appDirectory || pwd;
+    const cacheConfig = await (0, node_namespaceObject.loadCacheConfig)(loadCachePwd);
+    serverBase.notFound((c)=>{
+        const monitors = c.get('monitors');
+        (0, server_core_namespaceObject.onError)(server_core_namespaceObject.ErrorDigest.ENOTF, '404 not found', monitors, c.req.raw);
+        return c.html((0, server_core_namespaceObject.createErrorHtml)(404), 404);
+    });
+    serverBase.onError(async (err, c)=>{
+        const monitors = c.get('monitors');
+        (0, server_core_namespaceObject.onError)(server_core_namespaceObject.ErrorDigest.EINTER, err, monitors, c.req.raw);
+        if (serverErrorHandler) try {
+            const result = await serverErrorHandler(err, c);
+            if (result instanceof Response) return result;
+        } catch (configError) {
+            utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
+        }
+        const bffPrefix = config.bff?.prefix || '/api';
+        const bffPrefixList = Array.isArray(bffPrefix) ? bffPrefix : [
+            bffPrefix
+        ];
+        const isApiPath = bffPrefixList.some((prefix)=>c.req.path.startsWith(prefix));
+        if (isApiPath) return c.json({
+            message: err?.message || '[BFF] Internal Server Error'
+        }, err?.status || 500);
+        return c.html((0, server_core_namespaceObject.createErrorHtml)(500), 500);
+    });
+    const loggerOptions = config.server.logger;
+    const { middlewares, renderMiddlewares } = options.serverConfig || {};
+    const plugins = [
+        ...nodeServer ? [
+            (0, node_namespaceObject.injectNodeSeverPlugin)({
+                nodeServer
+            })
+        ] : [],
+        ...(0, server_core_namespaceObject.createDefaultPlugins)({
+            cacheConfig,
+            staticGenerate: options.staticGenerate,
+            logger: false === loggerOptions ? false : optLogger || getLogger(loggerOptions)
+        }),
+        (0, server_core_namespaceObject.injectConfigMiddlewarePlugin)(middlewares, renderMiddlewares),
+        ...options.plugins || [],
+        (0, node_namespaceObject.injectResourcePlugin)(),
+        (0, node_namespaceObject.injectRscManifestPlugin)(enableRsc),
+        (0, node_namespaceObject.serverStaticPlugin)(),
+        (0, server_core_namespaceObject.faviconPlugin)(),
+        (0, server_core_namespaceObject.renderPlugin)()
+    ];
+    serverBase.addPlugins(plugins);
+}
+exports.applyPlugins = __webpack_exports__.applyPlugins;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyPlugins"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,89 @@
+"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__, {
+    TelemetryCanaryOrchestrator: ()=>telemetry_js_namespaceObject.TelemetryCanaryOrchestrator,
+    TelemetryRegistry: ()=>telemetry_js_namespaceObject.TelemetryRegistry,
+    TelemetryStartupHealthError: ()=>telemetry_js_namespaceObject.TelemetryStartupHealthError,
+    applyPlugins: ()=>external_apply_js_namespaceObject.applyPlugins,
+    createOtlpTelemetryExporter: ()=>telemetry_js_namespaceObject.createOtlpTelemetryExporter,
+    createProdServer: ()=>createProdServer,
+    createTelemetryAwareMetrics: ()=>telemetry_js_namespaceObject.createTelemetryAwareMetrics,
+    createVictoriaMetricsTelemetryExporter: ()=>telemetry_js_namespaceObject.createVictoriaMetricsTelemetryExporter,
+    default: ()=>src,
+    hasEnabledTelemetryExporters: ()=>telemetry_js_namespaceObject.hasEnabledTelemetryExporters,
+    loadServerPlugins: ()=>node_namespaceObject.loadServerPlugins
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const node_namespaceObject = require("@modern-js/server-core/node");
+const external_apply_js_namespaceObject = require("./apply.js");
+const telemetry_js_namespaceObject = require("./libs/telemetry.js");
+const createProdServer = async (options)=>{
+    await (0, node_namespaceObject.loadServerEnv)(options);
+    const serverBaseOptions = options;
+    const serverCliConfig = 'production' === process.env.NODE_ENV ? (0, node_namespaceObject.loadServerCliConfig)(options.pwd, options.config) : options.config;
+    if (serverCliConfig) serverBaseOptions.config = serverCliConfig;
+    const serverRuntimeConfig = await (0, node_namespaceObject.loadServerRuntimeConfig)(options.serverConfigPath);
+    if (serverRuntimeConfig) {
+        serverBaseOptions.serverConfig = serverRuntimeConfig;
+        serverBaseOptions.plugins = [
+            ...serverRuntimeConfig.plugins || [],
+            ...options.plugins || []
+        ];
+    }
+    const server = (0, server_core_namespaceObject.createServerBase)(serverBaseOptions);
+    const nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server));
+    await (0, external_apply_js_namespaceObject.applyPlugins)(server, options, nodeServer);
+    await server.init();
+    return nodeServer;
+};
+const src = createProdServer;
+exports.TelemetryCanaryOrchestrator = __webpack_exports__.TelemetryCanaryOrchestrator;
+exports.TelemetryRegistry = __webpack_exports__.TelemetryRegistry;
+exports.TelemetryStartupHealthError = __webpack_exports__.TelemetryStartupHealthError;
+exports.applyPlugins = __webpack_exports__.applyPlugins;
+exports.createOtlpTelemetryExporter = __webpack_exports__.createOtlpTelemetryExporter;
+exports.createProdServer = __webpack_exports__.createProdServer;
+exports.createTelemetryAwareMetrics = __webpack_exports__.createTelemetryAwareMetrics;
+exports.createVictoriaMetricsTelemetryExporter = __webpack_exports__.createVictoriaMetricsTelemetryExporter;
+exports["default"] = __webpack_exports__["default"];
+exports.hasEnabledTelemetryExporters = __webpack_exports__.hasEnabledTelemetryExporters;
+exports.loadServerPlugins = __webpack_exports__.loadServerPlugins;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "applyPlugins",
+    "createOtlpTelemetryExporter",
+    "createProdServer",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "default",
+    "hasEnabledTelemetryExporters",
+    "loadServerPlugins"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/contractGateAutopilot.js

@@ -0,0 +1,36 @@
+"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__, {
+    ContractGateAutopilot: ()=>server_core_namespaceObject.ContractGateAutopilot
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+exports.ContractGateAutopilot = __webpack_exports__.ContractGateAutopilot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ContractGateAutopilot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/loadConfig.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    getServerConfigPath: ()=>getServerConfigPath,
+    loadConfig: ()=>loadConfig,
+    requireConfig: ()=>requireConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_flatted_namespaceObject = require("flatted");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const getServerConfigPath = (distDirectory, serverConfigFile)=>{
+    const fileName = serverConfigFile || 'server.js';
+    return external_path_default().join(distDirectory, fileName);
+};
+const requireConfig = (serverConfigPath)=>{
+    if (utils_namespaceObject.fs.pathExistsSync(serverConfigPath)) return (0, utils_namespaceObject.compatibleRequire)(serverConfigPath) || {};
+    return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath })=>{
+    let outputConfig = {};
+    if (utils_namespaceObject.fs.pathExistsSync(resolvedConfigPath)) try {
+        const content = utils_namespaceObject.fs.readFileSync(resolvedConfigPath, 'utf8');
+        outputConfig = (0, external_flatted_namespaceObject.parse)(content) || {};
+    } catch (_error) {
+        outputConfig = {};
+    }
+    return utils_namespaceObject.lodash.merge({}, outputConfig, serverConfig || {}, cliConfig || {});
+};
+exports.getServerConfigPath = __webpack_exports__.getServerConfigPath;
+exports.loadConfig = __webpack_exports__.loadConfig;
+exports.requireConfig = __webpack_exports__.requireConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getServerConfigPath",
+    "loadConfig",
+    "requireConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/metrics.js

@@ -0,0 +1,41 @@
+"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__, {
+    metrics: ()=>metrics
+});
+const noop = ()=>{};
+const metrics = {
+    emitCounter: noop,
+    emitTimer: noop,
+    gauges: noop
+};
+exports.metrics = __webpack_exports__.metrics;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "metrics"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/render/index.js

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    createRenderHandler: ()=>createRenderHandler
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_namespaceObject = require("../../constants");
+const shouldFlushServerHeader_namespaceObject = require("../preload/shouldFlushServerHeader");
+const external_reader_namespaceObject = require("./reader");
+const external_ssr_js_namespaceObject = require("./ssr.js");
+const external_static_namespaceObject = require("./static");
+const external_utils_js_namespaceObject = require("./utils.js");
+const calcFallback = (metaName)=>`x-${(0, utils_namespaceObject.cutNameByHyphen)(metaName)}-ssr-fallback`;
+const readUnsafeHeaders = (ssrConfig)=>{
+    if (!ssrConfig || 'object' != typeof ssrConfig) return;
+    const unsafeHeaders = ssrConfig.unsafeHeaders;
+    if (!Array.isArray(unsafeHeaders)) return;
+    return unsafeHeaders.filter((header)=>'string' == typeof header && header.trim().length > 0);
+};
+const resolveUnsafeHeaders = (conf, entryName)=>{
+    if (!entryName) return readUnsafeHeaders(conf.server?.ssr);
+    const entrySSRConfig = conf.server?.ssrByEntries?.[entryName];
+    return readUnsafeHeaders(entrySSRConfig) ?? readUnsafeHeaders(conf.server?.ssr);
+};
+const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = 'modern-js' })=>async function({ ctx, route, runner }) {
+        if (ctx.resHasHandled()) return null;
+        const { entryPath, urlPath } = route;
+        const unsafeHeaders = resolveUnsafeHeaders(conf, route.entryName);
+        const entry = external_path_default().join(distDir, entryPath);
+        if (!route.isSPA) {
+            const result = await (0, external_static_namespaceObject.handleDirectory)(ctx, entry, urlPath);
+            return result;
+        }
+        const templatePath = entry;
+        const content = await (0, external_reader_namespaceObject.readFile)(templatePath);
+        if (!content) return null;
+        const useCSR = forceCSR && (ctx.query.csr || ctx.headers[calcFallback(metaName)]);
+        if (route.isSSR && !useCSR) try {
+            const userAgent = ctx.getReqHeader('User-Agent');
+            const disablePreload = Boolean(ctx.headers[`x-${(0, utils_namespaceObject.cutNameByHyphen)(metaName)}-disable-preload`]);
+            if ((0, shouldFlushServerHeader_namespaceObject.shouldFlushServerHeader)(conf.server, userAgent, disablePreload)) {
+                const { flushServerHeader } = await import("../preload");
+                flushServerHeader({
+                    serverConf: conf.server,
+                    ctx,
+                    distDir,
+                    template: content.toString(),
+                    headers: {
+                        'Content-Type': utils_namespaceObject.mime.contentType(external_path_default().extname(templatePath))
+                    }
+                });
+            }
+            const ssrRenderOptions = {
+                distDir,
+                entryName: route.entryName,
+                urlPath: route.urlPath,
+                bundle: route.bundle,
+                template: content.toString(),
+                staticGenerate,
+                unsafeHeaders,
+                nonce
+            };
+            const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : external_ssr_js_namespaceObject.render(ctx, {
+                distDir,
+                entryName: route.entryName,
+                urlPath: route.urlPath,
+                bundle: route.bundle,
+                template: content.toString(),
+                staticGenerate,
+                unsafeHeaders,
+                nonce
+            }, runner));
+            return result;
+        } catch (err) {
+            ctx.error(external_constants_namespaceObject.ERROR_DIGEST.ERENDER, err.stack || err.message);
+            ctx.res.set(calcFallback(metaName), '1');
+        }
+        return {
+            content: route.entryName ? (0, external_utils_js_namespaceObject.injectServerData)(content.toString(), ctx, {
+                unsafeHeaders
+            }) : content,
+            contentType: utils_namespaceObject.mime.contentType(external_path_default().extname(templatePath))
+        };
+    };
+exports.createRenderHandler = __webpack_exports__.createRenderHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRenderHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/render/ssr.js

@@ -0,0 +1,118 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    render: ()=>render
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_cache_namespaceObject = require("./cache");
+var external_cache_default = /*#__PURE__*/ __webpack_require__.n(external_cache_namespaceObject);
+const external_measure_namespaceObject = require("./measure");
+const external_utils_js_namespaceObject = require("./utils.js");
+const render = async (ctx, renderOptions, runner)=>{
+    const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, unsafeHeaders, nonce } = renderOptions;
+    const bundleJS = external_path_default().join(distDir, bundle);
+    const loadableUri = external_path_default().join(distDir, utils_namespaceObject.LOADABLE_STATS_FILE);
+    const loadableStats = utils_namespaceObject.fs.existsSync(loadableUri) ? require(loadableUri) : '';
+    const routesManifestUri = external_path_default().join(distDir, utils_namespaceObject.ROUTE_MANIFEST_FILE);
+    const routeManifest = utils_namespaceObject.fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
+    const context = {
+        request: {
+            baseUrl: urlPath,
+            params: ctx.params,
+            pathname: ctx.path,
+            host: ctx.host,
+            query: ctx.query,
+            url: ctx.href,
+            headers: ctx.headers
+        },
+        response: {
+            setHeader: (key, value)=>ctx.res.setHeader(key, value),
+            status: (code)=>{
+                ctx.res.statusCode = code;
+            },
+            locals: ctx.res?.locals || {}
+        },
+        redirection: {},
+        template,
+        loadableStats,
+        routeManifest,
+        entryName,
+        staticGenerate,
+        logger: void 0,
+        metrics: void 0,
+        reporter: ctx.reporter,
+        serverTiming: ctx.serverTiming,
+        req: ctx.req,
+        res: ctx.res,
+        enableUnsafeCtx,
+        unsafeHeaders,
+        nonce
+    };
+    context.logger = (0, external_measure_namespaceObject.createLogger)(context, ctx.logger);
+    context.metrics = (0, external_measure_namespaceObject.createMetrics)(context, ctx.metrics);
+    runner.extendSSRContext(context);
+    const bundleJSContent = await Promise.resolve(require(bundleJS));
+    const serverRender = bundleJSContent[utils_namespaceObject.SERVER_RENDER_FUNCTION_NAME];
+    const content = await external_cache_default()(serverRender, ctx)(context);
+    const { url, status = 302 } = context.redirection;
+    if (url) return {
+        content: url,
+        contentType: '',
+        statusCode: status,
+        redirect: true
+    };
+    if ('string' == typeof content) return {
+        content: (0, external_utils_js_namespaceObject.injectServerData)(content, ctx, {
+            unsafeHeaders
+        }),
+        contentType: utils_namespaceObject.mime.contentType('html')
+    };
+    return {
+        content: '',
+        contentStream: (0, external_utils_js_namespaceObject.injectServerDataStream)(content, ctx, {
+            unsafeHeaders
+        }),
+        contentType: utils_namespaceObject.mime.contentType('html')
+    };
+};
+exports.render = __webpack_exports__.render;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "render"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});