@bleedingdev/modern-js-server 3.5.0-ultramodern.10 → 3.5.0-ultramodern.100

package/dist/cjs/createDevServer.js

@@ -43,7 +43,10 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 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");
 const external_dev_js_namespaceObject = require("./dev.js");
+const reloadManager_js_namespaceObject = require("./dev-tools/reloadManager.js");
+const runtimeOptions_js_namespaceObject = require("./dev-tools/runtimeOptions.js");
 const index_js_namespaceObject = require("./helpers/index.js");
 async function createDevServer(options, applyPlugins) {
     const { config, pwd, serverConfigPath, builder } = options;
@@ -62,33 +65,76 @@ async function createDevServer(options, applyPlugins) {
             ...options.plugins || []
         ]
     };
-    const server = (0, server_core_namespaceObject.createServerBase)(prodServerOptions);
-    const devHttpsOption = 'object' == typeof dev && dev.https;
-    const isHttp2 = !!devHttpsOption;
-    let nodeServer;
-    if (devHttpsOption) {
-        const { genHttpsOptions } = await import("./dev-tools/https/index.js");
-        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
-        nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server), httpsOptions, isHttp2);
-    } else nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server));
-    const promise = (0, index_js_namespaceObject.getDevAssetPrefix)(builder);
     let compiler = null;
     builder?.onAfterCreateCompiler((context)=>{
         compiler = context.compiler;
     });
+    const assetPrefixPromise = (0, index_js_namespaceObject.getDevAssetPrefix)(builder);
     const builderDevServer = await builder?.createDevServer({
         runCompile: options.runCompile
     });
-    server.addPlugins([
-        (0, external_dev_js_namespaceObject.devPlugin)({
-            ...options,
-            builderDevServer
-        }, compiler)
-    ]);
-    const assetPrefix = await promise;
-    if (assetPrefix) prodServerOptions.config.output.assetPrefix = assetPrefix;
-    await applyPlugins(server, prodServerOptions, nodeServer);
-    await server.init();
+    const assetPrefix = await assetPrefixPromise;
+    let currentRuntimeServer;
+    let nodeServer;
+    const buildRuntimeServer = async ()=>{
+        const freshServerConfig = await (0, node_namespaceObject.loadServerRuntimeConfig)(serverConfigPath) || {};
+        const runtimeOptions = (0, runtimeOptions_js_namespaceObject.createRuntimeServerOptions)({
+            ...prodServerOptions,
+            serverConfig: {
+                ...freshServerConfig,
+                ...options.serverConfig
+            },
+            plugins: [
+                ...freshServerConfig.plugins || [],
+                ...options.plugins || []
+            ]
+        }, assetPrefix);
+        const runtimeServer = (0, server_core_namespaceObject.createServerBase)(runtimeOptions);
+        runtimeServer.addPlugins([
+            (0, external_dev_js_namespaceObject.devRuntimeMiddlewarePlugin)({
+                ...options,
+                builderDevServer
+            }, compiler)
+        ]);
+        await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
+        await runtimeServer.init();
+        currentRuntimeServer = runtimeServer;
+        return runtimeServer.handle;
+    };
+    const pendingReloadFiles = new Set();
+    const reloadManager = (0, reloadManager_js_namespaceObject.createReloadManager)({
+        build: buildRuntimeServer,
+        onReload: ()=>{
+            const files = Array.from(pendingReloadFiles);
+            pendingReloadFiles.clear();
+            utils_namespaceObject.logger.info(files.length > 0 ? `Server runtime reloaded (${files.join(', ')})` : 'Server runtime reloaded');
+        }
+    });
+    const devHttpsOption = 'object' == typeof dev && dev.https;
+    const isHttp2 = !!devHttpsOption;
+    if (devHttpsOption) {
+        const { genHttpsOptions } = await import("./dev-tools/https/index.js");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await (0, node_namespaceObject.createNodeServer)(reloadManager.handle, httpsOptions, isHttp2);
+    } else nodeServer = await (0, node_namespaceObject.createNodeServer)(reloadManager.handle);
+    reloadManager.setHandle(await buildRuntimeServer());
+    (0, external_dev_js_namespaceObject.setupDevInfra)({
+        config,
+        pwd,
+        distDir,
+        apiDir: options.appContext?.apiDirectory,
+        sharedDir: options.appContext?.sharedDirectory,
+        builder,
+        builderDevServer,
+        compiler,
+        nodeServer,
+        getRuntimeServer: ()=>currentRuntimeServer,
+        onFileChange: (filepath)=>{
+            pendingReloadFiles.add(external_node_path_default().relative(pwd, filepath));
+            reloadManager.schedule();
+        },
+        onClose: ()=>reloadManager.close()
+    });
     const afterListen = async ()=>{
         await builderDevServer?.afterListen();
     };

package/dist/cjs/dev-tools/reloadManager.js

@@ -0,0 +1,226 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    ReloadManager: ()=>ReloadManager,
+    createReloadManager: ()=>createReloadManager
+});
+const utils_namespaceObject = require("@modern-js/utils");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+const DEFAULT_DEBOUNCE_MS = 300;
+const notReadyHandle = ()=>new Response('Dev server is starting…', {
+        status: 503,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8'
+        }
+    });
+var _current = /*#__PURE__*/ new WeakMap(), _build = /*#__PURE__*/ new WeakMap(), _debounceMs = /*#__PURE__*/ new WeakMap(), _onReload = /*#__PURE__*/ new WeakMap(), _onError = /*#__PURE__*/ new WeakMap(), _onReloadError = /*#__PURE__*/ new WeakMap(), _debounceTimer = /*#__PURE__*/ new WeakMap(), _running = /*#__PURE__*/ new WeakMap(), _pending = /*#__PURE__*/ new WeakMap(), _runningPromise = /*#__PURE__*/ new WeakMap(), _closed = /*#__PURE__*/ new WeakMap(), _runLoop = /*#__PURE__*/ new WeakSet(), _reportBuildError = /*#__PURE__*/ new WeakSet(), _reportReloadCallbackError = /*#__PURE__*/ new WeakSet();
+class ReloadManager {
+    setHandle(handle) {
+        _class_private_field_set(this, _current, handle);
+    }
+    get handle() {
+        return (request, ...args)=>_class_private_field_get(this, _current).call(this, request, ...args);
+    }
+    get currentHandle() {
+        return _class_private_field_get(this, _current);
+    }
+    get isReloading() {
+        return _class_private_field_get(this, _running);
+    }
+    schedule() {
+        if (_class_private_field_get(this, _closed)) return;
+        if (_class_private_field_get(this, _debounceTimer)) clearTimeout(_class_private_field_get(this, _debounceTimer));
+        _class_private_field_set(this, _debounceTimer, setTimeout(()=>{
+            _class_private_field_set(this, _debounceTimer, null);
+            this.reloadNow();
+        }, _class_private_field_get(this, _debounceMs)));
+    }
+    async reloadNow() {
+        if (_class_private_field_get(this, _closed)) return;
+        if (_class_private_field_get(this, _running)) {
+            _class_private_field_set(this, _pending, true);
+            return _class_private_field_get(this, _runningPromise) ?? Promise.resolve();
+        }
+        _class_private_field_set(this, _running, true);
+        _class_private_field_set(this, _runningPromise, _class_private_method_get(this, _runLoop, runLoop).call(this));
+        try {
+            await _class_private_field_get(this, _runningPromise);
+        } finally{
+            _class_private_field_set(this, _running, false);
+            _class_private_field_set(this, _runningPromise, null);
+        }
+    }
+    close() {
+        _class_private_field_set(this, _closed, true);
+        _class_private_field_set(this, _pending, false);
+        if (_class_private_field_get(this, _debounceTimer)) {
+            clearTimeout(_class_private_field_get(this, _debounceTimer));
+            _class_private_field_set(this, _debounceTimer, null);
+        }
+    }
+    constructor(options){
+        _class_private_method_init(this, _runLoop);
+        _class_private_method_init(this, _reportBuildError);
+        _class_private_method_init(this, _reportReloadCallbackError);
+        _class_private_field_init(this, _current, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _build, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _debounceMs, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onReload, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onError, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onReloadError, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _debounceTimer, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _running, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _pending, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _runningPromise, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _closed, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _debounceTimer, null);
+        _class_private_field_set(this, _running, false);
+        _class_private_field_set(this, _pending, false);
+        _class_private_field_set(this, _runningPromise, null);
+        _class_private_field_set(this, _closed, false);
+        _class_private_field_set(this, _current, options.initialHandle ?? notReadyHandle);
+        _class_private_field_set(this, _build, options.build);
+        _class_private_field_set(this, _debounceMs, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+        _class_private_field_set(this, _onReload, options.onReload);
+        _class_private_field_set(this, _onError, options.onError);
+        _class_private_field_set(this, _onReloadError, options.onReloadError);
+    }
+}
+async function runLoop() {
+    var _this, _this1;
+    do {
+        _class_private_field_set(this, _pending, false);
+        let next;
+        try {
+            next = await _class_private_field_get(this, _build).call(this);
+        } catch (error) {
+            _class_private_method_get(this, _reportBuildError, reportBuildError).call(this, error);
+            continue;
+        }
+        if (_class_private_field_get(this, _closed)) return;
+        _class_private_field_set(this, _current, next);
+        try {
+            null == (_this = _class_private_field_get(_this1 = this, _onReload)) || _this.call(_this1, next);
+        } catch (callbackError) {
+            _class_private_method_get(this, _reportReloadCallbackError, reportReloadCallbackError).call(this, callbackError);
+        }
+    }while (_class_private_field_get(this, _pending) && !_class_private_field_get(this, _closed));
+}
+function reportBuildError(error) {
+    if (_class_private_field_get(this, _onError)) _class_private_field_get(this, _onError).call(this, error);
+    else utils_namespaceObject.logger.error(`[dev-server] runtime reload build failed, keep serving previous handle:\n${error instanceof Error ? error.stack ?? error.message : error}`);
+}
+function reportReloadCallbackError(error) {
+    if (_class_private_field_get(this, _onReloadError)) _class_private_field_get(this, _onReloadError).call(this, error);
+    else utils_namespaceObject.logger.warn(`[dev-server] onReload callback failed after a successful swap (handle is already active):\n${error instanceof Error ? error.stack ?? error.message : error}`);
+}
+function createReloadManager(options) {
+    return new ReloadManager(options);
+}
+exports.ReloadManager = __webpack_exports__.ReloadManager;
+exports.createReloadManager = __webpack_exports__.createReloadManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ReloadManager",
+    "createReloadManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev-tools/runtimeOptions.js

@@ -0,0 +1,73 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+function createRuntimeServerOptions(base, assetPrefix) {
+    const baseConfig = base.config ?? {};
+    const baseOutput = baseConfig.output ?? {};
+    const baseServerConfig = base.serverConfig ?? {};
+    return {
+        ...base,
+        config: {
+            ...baseConfig,
+            output: {
+                ...baseOutput,
+                ...assetPrefix ? {
+                    assetPrefix
+                } : {}
+            }
+        },
+        serverConfig: {
+            ...baseServerConfig,
+            middlewares: [
+                ...baseServerConfig.middlewares ?? []
+            ],
+            renderMiddlewares: [
+                ...baseServerConfig.renderMiddlewares ?? []
+            ],
+            ...baseServerConfig.plugins ? {
+                plugins: [
+                    ...baseServerConfig.plugins
+                ]
+            } : {}
+        },
+        plugins: [
+            ...base.plugins ?? []
+        ]
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    createRuntimeServerOptions: ()=>createRuntimeServerOptions
+});
+exports.createRuntimeServerOptions = __webpack_exports__.createRuntimeServerOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRuntimeServerOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev-tools/watcher/dependencyTree.js

@@ -1,5 +1,14 @@
 "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, getters, values)=>{
         var define = (defs, kind)=>{
@@ -31,6 +40,8 @@ __webpack_require__.d(__webpack_exports__, {
     DependencyTree: ()=>DependencyTree,
     defaultIgnores: ()=>defaultIgnores
 });
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_minimatch_namespaceObject = require("minimatch");
 const defaultIgnores = [
     '**/coverage/**',
@@ -74,8 +85,9 @@ class DependencyTree {
         }
     }
     shouldIgnore(path) {
-        return !path || Boolean(this.ignore.find((rule)=>external_minimatch_namespaceObject.match([
-                path
+        const matchPath = path && external_node_path_default().isAbsolute(path) ? external_node_path_default().relative(process.cwd(), path) : path;
+        return !matchPath || Boolean(this.ignore.find((rule)=>external_minimatch_namespaceObject.match([
+                matchPath
             ], rule, {
                 dot: true
             }).length > 0));

package/dist/cjs/dev.js

@@ -28,45 +28,20 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    devPlugin: ()=>devPlugin
+    devRuntimeMiddlewarePlugin: ()=>devRuntimeMiddlewarePlugin,
+    setupDevInfra: ()=>setupDevInfra
 });
 const node_namespaceObject = require("@modern-js/server-core/node");
 const utils_namespaceObject = require("@modern-js/utils");
 const index_js_namespaceObject = require("./helpers/index.js");
-const devPlugin = (options, compiler)=>({
+const devRuntimeMiddlewarePlugin = (options, compiler)=>({
         name: '@modern-js/plugin-dev',
         setup (api) {
-            const { config, pwd, builder, builderDevServer } = options;
-            const closeCb = [];
+            const { pwd, builderDevServer } = options;
             const dev = (0, index_js_namespaceObject.getDevOptions)(options.dev);
             api.onPrepare(async ()=>{
-                const { middlewares: builderMiddlewares, close, connectWebSocket } = builderDevServer || {};
-                close && closeCb.push(close);
-                const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.getServerContext();
-                connectWebSocket && nodeServer && connectWebSocket({
-                    server: nodeServer
-                });
-                const hooks = api.getHooks();
-                builder?.onDevCompileDone(({ stats })=>{
-                    if ('server' !== stats.toJson({
-                        all: false
-                    }).name) (0, index_js_namespaceObject.onRepack)(distDirectory, hooks);
-                });
-                const { watchOptions } = config.server;
-                const watcher = (0, index_js_namespaceObject.startWatcher)({
-                    pwd,
-                    distDir: distDirectory,
-                    apiDir: apiDirectory || utils_namespaceObject.API_DIR,
-                    sharedDir: sharedDirectory || utils_namespaceObject.SHARED_DIR,
-                    watchOptions,
-                    server: serverBase
-                });
-                closeCb.push(watcher.close.bind(watcher));
-                closeCb.length > 0 && nodeServer?.on('close', ()=>{
-                    closeCb.forEach((cb)=>{
-                        cb();
-                    });
-                });
+                const { middlewares: builderMiddlewares } = builderDevServer || {};
+                const { middlewares } = api.getServerContext();
                 const before = [];
                 const after = [];
                 const { setupMiddlewares = [] } = dev;
@@ -84,7 +59,7 @@ const devPlugin = (options, compiler)=>({
                         handler: (0, node_namespaceObject.connectMid2HonoMid)(middleware)
                     });
                 });
-                const mockMiddleware = await (0, index_js_namespaceObject.getMockMiddleware)(pwd);
+                const mockMiddleware = await (0, index_js_namespaceObject.getMockMiddleware)(pwd, options.config?.dev?.mockDir);
                 middlewares.push({
                     name: 'mock-dev',
                     handler: mockMiddleware
@@ -106,9 +81,67 @@ const devPlugin = (options, compiler)=>({
             });
         }
     });
-exports.devPlugin = __webpack_exports__.devPlugin;
+function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer }) {
+    const { close, connectWebSocket } = builderDevServer || {};
+    const closeCb = [];
+    close && closeCb.push(close);
+    connectWebSocket && nodeServer && connectWebSocket({
+        server: nodeServer
+    });
+    builder?.onDevCompileDone(({ stats })=>{
+        if ('server' !== stats.toJson({
+            all: false
+        }).name) {
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer) (0, index_js_namespaceObject.onRepack)(distDir, runtimeServer.hooks);
+        }
+    });
+    const { watchOptions } = config.server;
+    const mockDir = config.dev?.mockDir;
+    const mockPath = (0, index_js_namespaceObject.resolveMockDirectory)(pwd, mockDir);
+    const watcher = (0, index_js_namespaceObject.startWatcher)({
+        pwd,
+        distDir,
+        apiDir: apiDir || utils_namespaceObject.API_DIR,
+        sharedDir: sharedDir || utils_namespaceObject.SHARED_DIR,
+        mockDir,
+        watchOptions,
+        onChange: (filepath, event)=>{
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer && !(0, index_js_namespaceObject.isPathInsideDirectory)(filepath, mockPath)) {
+                const fileChangeEvent = {
+                    type: 'file-change',
+                    payload: [
+                        {
+                            filename: filepath,
+                            event
+                        }
+                    ]
+                };
+                Promise.resolve(runtimeServer.hooks.onReset.call({
+                    event: fileChangeEvent
+                })).catch((error)=>utils_namespaceObject.logger.error(error));
+            }
+            onFileChange(filepath, event);
+        }
+    });
+    closeCb.push(watcher.close.bind(watcher));
+    onClose && closeCb.push(onClose);
+    const close$ = ()=>{
+        closeCb.forEach((cb)=>{
+            cb();
+        });
+    };
+    closeCb.length > 0 && nodeServer?.on('close', close$);
+    return {
+        close: close$
+    };
+}
+exports.devRuntimeMiddlewarePlugin = __webpack_exports__.devRuntimeMiddlewarePlugin;
+exports.setupDevInfra = __webpack_exports__.setupDevInfra;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "devPlugin"
+    "devRuntimeMiddlewarePlugin",
+    "setupDevInfra"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true