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

package/dist/cjs/plugins/middlewares.js

@@ -0,0 +1,49 @@
+"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__, {
+    injectConfigMiddlewarePlugin: ()=>injectConfigMiddlewarePlugin
+});
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = [])=>({
+        name: '@modern-js/plugin-inject-config-middleware',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, renderMiddlewares } = api.getServerContext();
+                configMiddlewares.forEach((m)=>{
+                    middlewares.push(m);
+                });
+                configRenderMiddlewares.forEach((m)=>{
+                    renderMiddlewares.push(m);
+                });
+            });
+        }
+    });
+exports.injectConfigMiddlewarePlugin = __webpack_exports__.injectConfigMiddlewarePlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "injectConfigMiddlewarePlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/monitors.js

@@ -0,0 +1,192 @@
+"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__, {
+    initMonitorsPlugin: ()=>initMonitorsPlugin,
+    injectServerTiming: ()=>injectServerTiming,
+    injectloggerPlugin: ()=>injectloggerPlugin,
+    requestLatencyMiddleware: ()=>requestLatencyMiddleware
+});
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const external_constants_js_namespaceObject = require("../constants.js");
+function createMonitors() {
+    const coreMonitors = [];
+    const log = (level, message, args)=>{
+        const event = {
+            type: 'log',
+            payload: {
+                level,
+                message,
+                args
+            }
+        };
+        coreMonitors.forEach((monitor)=>monitor(event));
+    };
+    const mointors = {
+        push (monitor) {
+            coreMonitors.push(monitor);
+        },
+        error (message, ...args) {
+            log('error', message, args);
+        },
+        warn (message, ...args) {
+            log('warn', message, args);
+        },
+        debug (message, ...args) {
+            log('debug', message, args);
+        },
+        info (message, ...args) {
+            log('info', message, args);
+        },
+        trace (message, ...args) {
+            log('trace', message, args);
+        },
+        timing (name, dur, desc, tags, ...args) {
+            const event = {
+                type: 'timing',
+                payload: {
+                    name,
+                    dur,
+                    desc,
+                    tags,
+                    args
+                }
+            };
+            coreMonitors.forEach((monitor)=>monitor(event));
+        },
+        counter (name, tags, ...args) {
+            const event = {
+                type: 'counter',
+                payload: {
+                    name,
+                    args,
+                    tags
+                }
+            };
+            coreMonitors.forEach((monitor)=>monitor(event));
+        }
+    };
+    return mointors;
+}
+const initMonitorsPlugin = ()=>({
+        name: '@modern-js/init-mointor',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'init-monitor',
+                    handler: async (c, next)=>{
+                        if (!c.get('monitors')) {
+                            const monitors = createMonitors();
+                            c.set('monitors', monitors);
+                        }
+                        return next();
+                    },
+                    order: 'pre'
+                });
+            });
+        }
+    });
+const injectloggerPlugin = (inputLogger)=>({
+        name: '@modern-js/inject-logger',
+        setup (api) {
+            const logger = inputLogger;
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'inject-logger',
+                    handler: async (c, next)=>{
+                        const pathname = c.req.path;
+                        const loggerMonitor = (event)=>{
+                            if ('log' === event.type) {
+                                const { level, message, args } = event.payload;
+                                if ('trace' === level) logger.info(message, ...args || []);
+                                else logger[level](message, ...args || []);
+                            }
+                            if ('timing' === event.type) {
+                                const { name, dur, desc } = event.payload;
+                                if (desc) logger.debug(`%s Debug - ${name}, cost: %s, req.url = %s `, desc, dur, pathname);
+                                else logger.debug(`Debug - ${name}, cost: %s, req.url = %s`, dur, pathname);
+                            }
+                        };
+                        const monitors = c.get('monitors');
+                        monitors?.push(loggerMonitor);
+                        return next();
+                    }
+                });
+            });
+        }
+    });
+const injectServerTiming = ()=>({
+        name: '@modern-js/inject-server-timing',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, metaName } = api.getServerContext();
+                middlewares.push({
+                    name: 'inject-server-timing',
+                    handler: async (c, next)=>{
+                        const serverTimings = [];
+                        const timingMonitor = (event)=>{
+                            if ('timing' === event.type) serverTimings.push(event.payload);
+                        };
+                        const monitors = c.get('monitors');
+                        monitors?.push(timingMonitor);
+                        await next();
+                        serverTimings.forEach((serverTiming)=>{
+                            const { name, desc, dur } = serverTiming;
+                            const _name = `bd-${metaName}-${name}`;
+                            const value = `${_name};${desc ? `decs="${desc}";` : ''} dur=${dur}`;
+                            c.header(external_constants_js_namespaceObject.SERVER_TIMING, value, {
+                                append: true
+                            });
+                        });
+                    }
+                });
+            });
+        }
+    });
+function requestLatencyMiddleware() {
+    return async (c, next)=>{
+        const monitors = c.get('monitors');
+        if (!monitors) return void await next();
+        const getCost = (0, time_namespaceObject.time)();
+        await next();
+        const cost = getCost();
+        monitors.timing(external_constants_js_namespaceObject.ServerTimings.SERVER_HANDLE_REQUEST, cost);
+    };
+}
+exports.initMonitorsPlugin = __webpack_exports__.initMonitorsPlugin;
+exports.injectServerTiming = __webpack_exports__.injectServerTiming;
+exports.injectloggerPlugin = __webpack_exports__.injectloggerPlugin;
+exports.requestLatencyMiddleware = __webpack_exports__.requestLatencyMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initMonitorsPlugin",
+    "injectServerTiming",
+    "injectloggerPlugin",
+    "requestLatencyMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/processedBy.js

@@ -0,0 +1,50 @@
+"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__, {
+    processedByPlugin: ()=>processedByPlugin
+});
+const processedByPlugin = ()=>({
+        name: '@modern-js/plugin-processed',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'processed-by',
+                    handler: async (c, next)=>{
+                        await next();
+                        c.header('X-Processed-By', 'Modern.js');
+                    }
+                });
+            });
+        }
+    });
+exports.processedByPlugin = __webpack_exports__.processedByPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "processedByPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,74 @@
+"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__, {
+    csrRscRender: ()=>csrRscRender
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_utils_js_namespaceObject = require("./utils.js");
+const csrRscRender = async (req, options)=>{
+    const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, onError, onTiming, staticGenerate, html } = 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,
+        html,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter: reporter
+    };
+    if (!serverBundle) return new Response('Cannot find server bundle for RSC', {
+        status: 500
+    });
+    const renderRscStreamHandler = await serverBundle.renderRscStreamHandler;
+    if (!renderRscStreamHandler) return new Response('Cannot find render handler for RSC', {
+        status: 500
+    });
+    const response = await renderRscStreamHandler(req, requestHandlerOptions);
+    return response;
+};
+exports.csrRscRender = __webpack_exports__.csrRscRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "csrRscRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,53 @@
+"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__, {
+    dataHandler: ()=>dataHandler
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const dataHandler = async (request, { routeInfo, serverRoutes, monitors, onError, onTiming, serverManifest, loaderContext })=>{
+    const serverLoaderModule = serverManifest?.loaderBundles?.[routeInfo.entryName || constants_namespaceObject.MAIN_ENTRY_NAME];
+    if (!serverLoaderModule) return;
+    const { routes, handleRequest } = serverLoaderModule;
+    const response = await handleRequest({
+        request,
+        serverRoutes,
+        context: {
+            monitors,
+            loaderContext
+        },
+        onTiming,
+        onError,
+        routes
+    });
+    return response;
+};
+exports.dataHandler = __webpack_exports__.dataHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "dataHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,158 @@
+"use strict";
+var __webpack_modules__ = {
+    "../../helper" (module) {
+        module.exports = require("../../helper.js");
+    },
+    "../../utils" (module) {
+        module.exports = require("../../utils/index.js");
+    },
+    "../monitors" (module) {
+        module.exports = require("../monitors.js");
+    },
+    "./inject" (module) {
+        module.exports = require("./inject.js");
+    }
+};
+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__.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__, {
+        renderPlugin: ()=>renderPlugin
+    });
+    var _helper__rspack_import_0 = __webpack_require__("../../helper");
+    var _utils__rspack_import_1 = __webpack_require__("../../utils");
+    var _monitors__rspack_import_2 = __webpack_require__("../monitors");
+    var _inject__rspack_import_3 = __webpack_require__("./inject");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _inject__rspack_import_3)if ([
+        "renderPlugin",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_inject__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const DYNAMIC_ROUTE_REG = /\/:./;
+    function escapeRegexSpecialChars(path) {
+        return path.replace(/[()[\]{}*+?.^$|\\]/g, '\\$&');
+    }
+    const renderPlugin = ()=>({
+            name: '@modern-js/plugin-render',
+            setup (api) {
+                api.onPrepare(async ()=>{
+                    const { middlewares, routes, render, renderMiddlewares } = api.getServerContext();
+                    if (!routes) return;
+                    const pageRoutes = getPageRoutes(routes);
+                    middlewares.push({
+                        name: 'page-latency',
+                        handler: (0, _monitors__rspack_import_2.requestLatencyMiddleware)()
+                    });
+                    for (const route of pageRoutes){
+                        const { urlPath: originUrlPath } = route;
+                        const isDynamic = DYNAMIC_ROUTE_REG.test(originUrlPath);
+                        const escapedPath = isDynamic ? originUrlPath : escapeRegexSpecialChars(originUrlPath);
+                        const urlPath = escapedPath.endsWith('/') ? `${escapedPath}*` : `${escapedPath}/*`;
+                        renderMiddlewares?.forEach((m)=>{
+                            middlewares.push({
+                                name: m.name,
+                                path: urlPath,
+                                handler: m.handler
+                            });
+                        });
+                        render && middlewares.push({
+                            name: "render",
+                            path: urlPath,
+                            handler: createRenderHandler(render)
+                        });
+                    }
+                });
+            }
+        });
+    function getPageRoutes(routes) {
+        return routes.filter((route)=>!route.isApi).sort(_utils__rspack_import_1.sortRoutes);
+    }
+    function createRenderHandler(render) {
+        return async (c, _)=>{
+            const reporter = c.get('reporter');
+            const monitors = c.get('monitors');
+            const templates = c.get('templates') || {};
+            const serverManifest = c.get('serverManifest') || {};
+            const rscServerManifest = c.get('rscServerManifest');
+            const rscClientManifest = c.get('rscClientManifest');
+            const rscSSRManifest = c.get('rscSSRManifest');
+            const locals = c.get('locals');
+            c.get('metrics');
+            const matchPathname = c.get('matchPathname');
+            const matchEntryName = c.get('matchEntryName');
+            const loaderContext = (0, _helper__rspack_import_0.getLoaderCtx)(c);
+            const contextForceCSR = c.get('forceCSR');
+            const request = c.req.raw;
+            const nodeReq = c.env.node?.req;
+            const res = await render(request, {
+                nodeReq,
+                monitors,
+                templates,
+                serverManifest,
+                rscServerManifest,
+                rscClientManifest,
+                rscSSRManifest,
+                loaderContext,
+                locals,
+                matchPathname,
+                matchEntryName,
+                contextForceCSR,
+                reporter
+            });
+            const { body, status, headers } = res;
+            const headersData = {};
+            headers.forEach((v, k)=>{
+                headersData[k] = v;
+            });
+            return c.body(body, status, headersData);
+        };
+    }
+})();
+exports.renderPlugin = __webpack_exports__.renderPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,92 @@
+"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__, {
+    getRenderHandler: ()=>getRenderHandler,
+    injectRenderHandlerPlugin: ()=>injectRenderHandlerPlugin
+});
+const external_render_js_namespaceObject = require("./render.js");
+const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig })=>({
+        name: '@modern-js/plugin-inject-render',
+        setup (api) {
+            api.onPrepare(async ()=>{
+                const { distDirectory: pwd, routes, metaName } = api.getServerContext();
+                const config = api.getServerConfig();
+                const hooks = api.getHooks();
+                if (!routes) return;
+                const onFallback = async (reason, error)=>{
+                    await hooks.fallback.call({
+                        reason,
+                        error
+                    });
+                };
+                const getRenderHandlerOptions = {
+                    pwd: pwd,
+                    routes,
+                    config,
+                    metaName,
+                    cacheConfig: cacheConfig,
+                    staticGenerate,
+                    onFallback
+                };
+                const render = await getRenderHandler(getRenderHandlerOptions);
+                api.updateServerContext({
+                    render,
+                    getRenderOptions: getRenderHandlerOptions
+                });
+            });
+        }
+    });
+async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback }) {
+    const ssrConfig = config.server?.ssr;
+    const ssrByEntries = config.server?.ssrByEntries;
+    const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
+    const forceCSRMap = new Map();
+    if (ssrByEntries) Object.entries(ssrByEntries).forEach(([entryName, ssrConfig])=>{
+        forceCSRMap.set(entryName, 'object' == typeof ssrConfig ? ssrConfig.forceCSR ?? false : false);
+    });
+    const render = (0, external_render_js_namespaceObject.createRender)({
+        routes,
+        pwd,
+        config,
+        staticGenerate,
+        cacheConfig,
+        forceCSR,
+        forceCSRMap,
+        nonce: config.security?.nonce,
+        metaName: metaName || 'modern-js',
+        onFallback
+    });
+    return render;
+}
+exports.getRenderHandler = __webpack_exports__.getRenderHandler;
+exports.injectRenderHandlerPlugin = __webpack_exports__.injectRenderHandlerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRenderHandler",
+    "injectRenderHandlerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});