@rstest/core 0.6.1 → 0.6.2

package/dist/0~628.js

@@ -1,1090 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
-import * as __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__ from "node:v8";
-import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
-import * as __WEBPACK_EXTERNAL_MODULE_tinypool__ from "tinypool";
-import * as __WEBPACK_EXTERNAL_MODULE_node_inspector_dd9822d6__ from "node:inspector";
-export const __webpack_id__ = "628";
-export const __webpack_ids__ = [
-    "628"
-];
-export const __webpack_modules__ = {
-    "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            XD: ()=>createRsbuildServer,
-            zh: ()=>prepareRsbuild
-        });
-        var external_node_url_ = __webpack_require__("node:url");
-        var core_ = __webpack_require__("@rsbuild/core");
-        var dist = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs");
-        var utils = __webpack_require__("./src/utils/index.ts");
-        var memory = __webpack_require__("./src/utils/memory.ts");
-        const RUNTIME_CHUNK_NAME = 'runtime';
-        const pluginBasic = (context)=>({
-                name: 'rstest:basic',
-                setup: (api)=>{
-                    api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig, name })=>{
-                        const { normalizedConfig: { resolve, source, output, tools, performance, dev, testEnvironment }, rootPath } = context.projects.find((p)=>p.environmentName === name);
-                        return mergeEnvironmentConfig(config, {
-                            performance,
-                            tools,
-                            resolve,
-                            source,
-                            output,
-                            dev
-                        }, {
-                            source: {
-                                define: {
-                                    'import.meta.rstest': "global['@rstest/core']",
-                                    'import.meta.env': 'process.env'
-                                }
-                            },
-                            output: {
-                                manifest: `${name}-manifest.json`,
-                                sourceMap: {
-                                    js: 'source-map'
-                                },
-                                distPath: {
-                                    root: context.projects.length > 1 ? `${utils.zZ}/${name}` : utils.zZ
-                                }
-                            },
-                            tools: {
-                                rspack: (config, { isProd, rspack })=>{
-                                    config.context = rootPath;
-                                    config.mode = isProd ? 'production' : 'development';
-                                    config.output ??= {};
-                                    config.output.iife = false;
-                                    config.output.importFunctionName = '__rstest_dynamic_import__';
-                                    config.output.devtoolModuleFilenameTemplate = '[absolute-resource-path]';
-                                    if (!config.devtool || !config.devtool.includes('inline')) config.devtool = 'nosources-source-map';
-                                    config.plugins.push(new rspack.experiments.RstestPlugin({
-                                        injectModulePathName: true,
-                                        importMetaPathName: true,
-                                        hoistMockModule: true,
-                                        manualMockRoot: dist.Ay.resolve(rootPath, '__mocks__')
-                                    }));
-                                    config.module.parser ??= {};
-                                    config.module.parser.javascript = {
-                                        importDynamic: false,
-                                        requireDynamic: false,
-                                        requireAsExpression: false,
-                                        requireResolve: false,
-                                        ...config.module.parser.javascript || {}
-                                    };
-                                    config.resolve ??= {};
-                                    config.resolve.extensions ??= [];
-                                    config.resolve.extensions.push('.cjs');
-                                    config.resolve.extensionAlias ??= {};
-                                    config.resolve.extensionAlias['.js'] = [
-                                        '.js',
-                                        '.ts',
-                                        '.tsx'
-                                    ];
-                                    config.resolve.extensionAlias['.jsx'] = [
-                                        '.jsx',
-                                        '.tsx'
-                                    ];
-                                    if ('node' === testEnvironment) config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
-                                        'main'
-                                    ];
-                                    config.resolve.byDependency ??= {};
-                                    config.resolve.byDependency.commonjs ??= {};
-                                    config.resolve.byDependency.commonjs.mainFields = [
-                                        'main',
-                                        '...'
-                                    ];
-                                    config.optimization = {
-                                        moduleIds: 'named',
-                                        chunkIds: 'named',
-                                        nodeEnv: false,
-                                        ...config.optimization || {},
-                                        runtimeChunk: {
-                                            name: `${name}-${RUNTIME_CHUNK_NAME}`
-                                        }
-                                    };
-                                }
-                            }
-                        });
-                    });
-                }
-            });
-        var external_node_path_ = __webpack_require__("node:path");
-        const PLUGIN_CSS_FILTER = 'rstest:css-filter';
-        const css_filter_dirname = external_node_path_["default"].dirname((0, external_node_url_.fileURLToPath)(import.meta.url));
-        const pluginCSSFilter = ()=>({
-                name: PLUGIN_CSS_FILTER,
-                setup (api) {
-                    api.modifyBundlerChain({
-                        order: 'post',
-                        handler: async (chain, { target, CHAIN_ID, environment })=>{
-                            const emitCss = environment.config.output.emitCss ?? 'web' === target;
-                            if (!emitCss) {
-                                const ruleIds = [
-                                    CHAIN_ID.RULE.CSS,
-                                    CHAIN_ID.RULE.SASS,
-                                    CHAIN_ID.RULE.LESS,
-                                    CHAIN_ID.RULE.STYLUS
-                                ];
-                                for (const ruleId of ruleIds){
-                                    if (!chain.module.rules.has(ruleId)) continue;
-                                    const rule = chain.module.rule(ruleId);
-                                    if (!rule.uses.has(CHAIN_ID.USE.CSS)) continue;
-                                    const cssLoaderOptions = rule.use(CHAIN_ID.USE.CSS).get('options');
-                                    if (cssLoaderOptions.modules && ('object' != typeof cssLoaderOptions.modules || false !== cssLoaderOptions.modules.auto)) rule.use('rstest-css-pre-filter').loader(external_node_path_["default"].join(css_filter_dirname, 'cssFilterLoader.mjs')).options({
-                                        modules: cssLoaderOptions.modules
-                                    }).after(ruleId);
-                                }
-                            }
-                        }
-                    });
-                }
-            });
-        class TestFileWatchPlugin {
-            contextToWatch = null;
-            constructor(contextToWatch){
-                this.contextToWatch = contextToWatch;
-            }
-            apply(compiler) {
-                compiler.hooks.afterCompile.tap('Rstest:TestFileWatchPlugin', (compilation)=>{
-                    if (null === this.contextToWatch) return;
-                    const contextDep = compilation.contextDependencies;
-                    if (!contextDep.has(this.contextToWatch)) contextDep.add(this.contextToWatch);
-                });
-            }
-        }
-        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, context })=>({
-                name: 'rstest:entry-watch',
-                setup: (api)=>{
-                    api.modifyRspackConfig(async (config, { environment })=>{
-                        if (isWatch) {
-                            config.plugins.push(new TestFileWatchPlugin(environment.config.root));
-                            config.entry = async ()=>{
-                                const sourceEntries = await globTestSourceEntries(environment.name);
-                                return {
-                                    ...sourceEntries,
-                                    ...setupFiles[environment.name]
-                                };
-                            };
-                            config.watchOptions ??= {};
-                            config.watchOptions.ignored = (0, utils.bg)(config.watchOptions.ignored || []);
-                            if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
-                            config.watchOptions.ignored.push(utils.EJ, context.normalizedConfig.coverage.reportsDirectory, '**/*.snap');
-                            const configFilePath = context.projects.find((project)=>project.environmentName === environment.name)?.configFilePath;
-                            if (configFilePath) config.watchOptions.ignored.push(configFilePath);
-                        } else {
-                            config.watch = false;
-                            config.watchOptions ??= {};
-                            config.watchOptions.ignored = '**/**';
-                            const sourceEntries = await globTestSourceEntries(environment.name);
-                            config.entry = {
-                                ...setupFiles[environment.name],
-                                ...sourceEntries
-                            };
-                        }
-                    });
-                }
-            });
-        var external_node_module_ = __webpack_require__("node:module");
-        const autoExternalNodeModules = ({ context, request, dependencyType, getResolve }, callback)=>{
-            if (!request) return callback();
-            if (request.startsWith('@swc/helpers/')) return callback();
-            const doExternal = (externalPath = request)=>{
-                callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : 'import');
-            };
-            const resolver = getResolve?.();
-            if (!resolver) return callback();
-            resolver(context, request, (err, resolvePath)=>{
-                if (err) return callback();
-                if (resolvePath && /node_modules/.test(resolvePath)) return doExternal(resolvePath);
-                return callback();
-            });
-        };
-        function autoExternalNodeBuiltin({ request, dependencyType }, callback) {
-            if (!request) return void callback();
-            const isNodeBuiltin = (0, external_node_module_.isBuiltin)(request) || utils.Uq.some((builtin)=>{
-                if ('string' == typeof builtin) return builtin === request;
-                return builtin.test(request);
-            });
-            if (isNodeBuiltin) callback(void 0, request, 'commonjs' === dependencyType ? 'commonjs' : 'module-import');
-            else callback();
-        }
-        const pluginExternal = (context)=>({
-                name: 'rstest:external',
-                setup: (api)=>{
-                    api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig, name })=>{
-                        const { normalizedConfig: { testEnvironment } } = context.projects.find((p)=>p.environmentName === name);
-                        return mergeEnvironmentConfig(config, {
-                            output: {
-                                externals: 'node' === testEnvironment ? [
-                                    autoExternalNodeModules
-                                ] : void 0
-                            },
-                            tools: {
-                                rspack: (config)=>{
-                                    config.externals = (0, utils.bg)(config.externals) || [];
-                                    config.externals.unshift({
-                                        '@rstest/core': 'global @rstest/core'
-                                    });
-                                    config.externalsPresets ??= {};
-                                    config.externalsPresets.node = false;
-                                    config.externals.push(autoExternalNodeBuiltin);
-                                }
-                            }
-                        });
-                    });
-                }
-            });
-        class IgnoreModuleNotFoundErrorPlugin {
-            apply(compiler) {
-                compiler.hooks.done.tap('Rstest:IgnoreModuleNotFoundPlugin', (stats)=>{
-                    for(let i = stats.compilation.errors.length - 1; i >= 0; i--)if (/Module not found/.test(stats.compilation.errors[i].message)) stats.compilation.errors.splice(i, 1);
-                });
-            }
-        }
-        const pluginIgnoreResolveError = {
-            name: 'rstest:ignore-resolve-error',
-            setup: (api)=>{
-                api.modifyRspackConfig(async (config)=>{
-                    config.plugins.push(new IgnoreModuleNotFoundErrorPlugin());
-                    config.optimization ??= {};
-                    config.optimization.emitOnErrors = true;
-                    config.ignoreWarnings ??= [];
-                    config.ignoreWarnings.push(/Module not found/);
-                });
-            }
-        };
-        const enable = void 0 !== __WEBPACK_EXTERNAL_MODULE_node_inspector_dd9822d6__["default"].url();
-        const pluginInspect = ()=>enable ? {
-                name: 'rstest:inspect',
-                setup: (api)=>{
-                    api.modifyRspackConfig(async (config)=>{
-                        config.devtool = 'inline-nosources-source-map';
-                        config.optimization ??= {};
-                        config.optimization.splitChunks = {
-                            ...config.optimization.splitChunks || {},
-                            maxSize: 1048576,
-                            chunks: 'all'
-                        };
-                    });
-                }
-            } : null;
-        var external_node_fs_ = __webpack_require__("node:fs");
-        const mockRuntime_dirname = external_node_path_["default"].dirname((0, external_node_url_.fileURLToPath)(import.meta.url));
-        class MockRuntimeRspackPlugin {
-            apply(compiler) {
-                const { RuntimeModule } = compiler.webpack;
-                class RetestImportRuntimeModule extends RuntimeModule {
-                    constructor(){
-                        super('rstest runtime');
-                    }
-                    generate() {
-                        const code = external_node_fs_["default"].readFileSync(external_node_path_["default"].join(mockRuntime_dirname, './mockRuntimeCode.js'), 'utf8');
-                        return code;
-                    }
-                }
-                compiler.hooks.compilation.tap('RstestMockPlugin', (compilation)=>{
-                    compilation.hooks.runtimeModule.tap('RstestMockChunkLoadingRuntimePlugin', (module)=>{
-                        if ('require_chunk_loading' === module.name) {
-                            const finalSource = module.source.source.toString('utf-8').replace('for (var moduleId in moreModules) {', "for (var moduleId in moreModules) {\n		if (Object.keys(__webpack_require__.rstest_original_modules).includes(moduleId)) continue;");
-                            module.source.source = Buffer.from(finalSource);
-                        }
-                        if ('define_property_getters' === module.name) {
-                            const finalSource = module.source.source.toString('utf-8').replace('enumerable: true, get:', 'enumerable: true, configurable: true, get:');
-                            module.source.source = Buffer.from(finalSource);
-                        }
-                    });
-                });
-                compiler.hooks.thisCompilation.tap('RstestMockPlugin', (compilation)=>{
-                    compilation.hooks.additionalTreeRuntimeRequirements.tap('RstestAddMockRuntimePlugin', (chunk)=>{
-                        compilation.addRuntimeModule(chunk, new RetestImportRuntimeModule());
-                    });
-                });
-            }
-        }
-        const pluginMockRuntime = {
-            name: 'rstest:mock-runtime',
-            setup: (api)=>{
-                api.modifyRspackConfig(async (config)=>{
-                    config.plugins.push(new MockRuntimeRspackPlugin());
-                });
-            }
-        };
-        class RstestCacheControlPlugin {
-            apply(compiler) {
-                const { RuntimeModule } = compiler.webpack;
-                class RetestCacheControlModule extends RuntimeModule {
-                    constructor(){
-                        super('rstest_cache_control');
-                    }
-                    generate() {
-                        return `
-global.setupIds = [];
-
-function __rstest_clean_core_cache__() {
-  if (typeof __webpack_require__ === 'undefined') {
-    return;
-  }
-  delete __webpack_module_cache__['@rstest/core'];
-
-  global.setupIds.forEach((id) => {
-    delete __webpack_module_cache__[id];
-  });
-}
-
-global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
-`;
-                    }
-                }
-                compiler.hooks.thisCompilation.tap('RstestCacheControlPlugin', (compilation)=>{
-                    compilation.hooks.additionalTreeRuntimeRequirements.tap('RstestAddCacheControlRuntimePlugin', (chunk)=>{
-                        compilation.addRuntimeModule(chunk, new RetestCacheControlModule());
-                    });
-                });
-            }
-        }
-        const pluginCacheControl = (setupFiles)=>({
-                name: 'rstest:cache-control',
-                setup: (api)=>{
-                    api.transform({
-                        test: setupFiles
-                    }, ({ code })=>({
-                            code: `
-          ${code}
-         if (global.setupIds && __webpack_module__.id) {
-  global.setupIds.push(__webpack_module__.id);
-}
-        `
-                        }));
-                    api.modifyRspackConfig(async (config)=>{
-                        config.plugins.push(new RstestCacheControlPlugin());
-                    });
-                }
-            });
-        const rsbuild_dirname = dist.Ay.dirname((0, external_node_url_.fileURLToPath)(import.meta.url));
-        function parseInlineSourceMapStr(code) {
-            const inlineSourceMapRegex = /\/\/# sourceMappingURL=data:application\/json(?:;charset=utf-8)?;base64,(.+)\s*$/m;
-            const match = code.match(inlineSourceMapRegex);
-            if (!match || !match[1]) return null;
-            try {
-                const base64Data = match[1];
-                const decodedStr = Buffer.from(base64Data, 'base64').toString('utf-8');
-                return decodedStr;
-            } catch (_error) {
-                return null;
-            }
-        }
-        const isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
-        const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
-            const { command, normalizedConfig: { isolate, dev = {}, coverage } } = context;
-            const debugMode = (0, utils._o)();
-            core_.logger.level = debugMode ? 'verbose' : 'error';
-            const writeToDisk = dev.writeToDisk || debugMode;
-            const rsbuildInstance = await (0, core_.createRsbuild)({
-                callerName: 'rstest',
-                rsbuildConfig: {
-                    root: context.rootPath,
-                    server: {
-                        printUrls: false,
-                        strictPort: false,
-                        middlewareMode: true,
-                        compress: false,
-                        cors: false,
-                        publicDir: false
-                    },
-                    dev: {
-                        hmr: false,
-                        writeToDisk
-                    },
-                    environments: Object.fromEntries(context.projects.map((project)=>[
-                            project.environmentName,
-                            {
-                                plugins: project.normalizedConfig.plugins,
-                                root: project.rootPath,
-                                output: {
-                                    target: 'node'
-                                }
-                            }
-                        ])),
-                    plugins: [
-                        pluginBasic(context),
-                        pluginIgnoreResolveError,
-                        pluginMockRuntime,
-                        pluginCSSFilter(),
-                        pluginEntryWatch({
-                            globTestSourceEntries,
-                            setupFiles,
-                            context,
-                            isWatch: 'watch' === command
-                        }),
-                        pluginExternal(context),
-                        !isolate ? pluginCacheControl(Object.values(setupFiles).flatMap((files)=>Object.values(files))) : null,
-                        pluginInspect()
-                    ].filter(Boolean)
-                }
-            });
-            if (coverage?.enabled && 'list' !== command) {
-                const { loadCoverageProvider } = await __webpack_require__.e("603").then(__webpack_require__.bind(__webpack_require__, "./src/coverage/index.ts"));
-                const { pluginCoverageCore } = await __webpack_require__.e("836").then(__webpack_require__.bind(__webpack_require__, "./src/coverage/plugin.ts"));
-                const { pluginCoverage } = await loadCoverageProvider(coverage, context.rootPath);
-                coverage.exclude.push(...Object.values(setupFiles).flatMap((files)=>Object.values(files)));
-                rsbuildInstance.addPlugins([
-                    pluginCoverage(coverage),
-                    pluginCoverageCore(coverage)
-                ]);
-            }
-            return rsbuildInstance;
-        };
-        const calcEntriesToRerun = (entries, chunks, buildData, runtimeChunkName)=>{
-            const entryToChunkHashesMap = new Map();
-            const buildChunkHashes = (entry)=>{
-                const validChunks = (entry.chunks || []).filter((chunk)=>chunk !== runtimeChunkName);
-                validChunks.forEach((chunkName)=>{
-                    const chunkInfo = chunks?.find((c)=>c.names?.includes(chunkName));
-                    if (chunkInfo) {
-                        const existing = entryToChunkHashesMap.get(entry.testPath) || {};
-                        existing[chunkName] = chunkInfo.hash ?? '';
-                        entryToChunkHashesMap.set(entry.testPath, existing);
-                    }
-                });
-            };
-            (entries || []).forEach(buildChunkHashes);
-            const entryToChunkHashes = Array.from(entryToChunkHashesMap.entries()).map(([name, chunks])=>({
-                    name,
-                    chunks
-                }));
-            const affectedTestPaths = new Set();
-            const deletedEntries = [];
-            if (buildData.entryToChunkHashes) {
-                const prevMap = new Map(buildData.entryToChunkHashes.map((e)=>[
-                        e.name,
-                        e.chunks
-                    ]));
-                const currentNames = new Set(entryToChunkHashesMap.keys());
-                deletedEntries.push(...Array.from(prevMap.keys()).filter((name)=>!currentNames.has(name)));
-                const findAffectedEntry = (testPath)=>{
-                    const currentChunks = entryToChunkHashesMap.get(testPath);
-                    const prevChunks = prevMap.get(testPath);
-                    if (!currentChunks) return;
-                    if (!prevChunks) return void affectedTestPaths.add(testPath);
-                    const hasChanges = Object.entries(currentChunks).some(([chunkName, hash])=>prevChunks[chunkName] !== hash);
-                    if (hasChanges) affectedTestPaths.add(testPath);
-                };
-                entryToChunkHashesMap.forEach((_, testPath)=>{
-                    findAffectedEntry(testPath);
-                });
-            }
-            buildData.entryToChunkHashes = entryToChunkHashes;
-            const affectedEntries = Array.from(affectedTestPaths).map((testPath)=>entries.find((e)=>e.testPath === testPath)).filter((entry)=>void 0 !== entry);
-            return {
-                affectedEntries,
-                deletedEntries
-            };
-        };
-        class AssetsMemorySafeMap extends Map {
-            set(key, value) {
-                if (this.has(key)) return this;
-                if (!(0, memory.i)()) this.clear();
-                return super.set(key, value);
-            }
-        }
-        const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildInstance, inspectedConfig })=>{
-            let rspackCompiler;
-            const rstestCompilerPlugin = {
-                name: 'rstest:compiler',
-                setup: (api)=>{
-                    api.modifyBundlerChain((chain)=>{
-                        chain.module.rule('rstest-mock-module-doppelgangers').test(/\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/).with({
-                            rstest: 'importActual'
-                        }).use('import-actual-loader').loader(dist.Ay.resolve(rsbuild_dirname, './importActualLoader.mjs')).end();
-                    });
-                    api.onAfterCreateCompiler(({ compiler })=>{
-                        rspackCompiler = compiler;
-                    });
-                }
-            };
-            rsbuildInstance.addPlugins([
-                rstestCompilerPlugin
-            ]);
-            const devServer = await rsbuildInstance.createDevServer({
-                getPortSilently: true
-            });
-            if ((0, utils._o)()) await rsbuildInstance.inspectConfig({
-                writeToDisk: true,
-                extraConfigs: {
-                    rstest: inspectedConfig
-                }
-            });
-            if (!rspackCompiler) throw new Error('rspackCompiler was not initialized');
-            const outputFileSystem = isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem;
-            if (!outputFileSystem) throw new Error(`Expect outputFileSystem to be defined, but got ${outputFileSystem}`);
-            const readFile = async (fileName)=>new Promise((resolve, reject)=>{
-                    outputFileSystem.readFile(fileName, (err, data)=>{
-                        if (err) reject(err);
-                        resolve('string' == typeof data ? data : data.toString());
-                    });
-                });
-            const buildData = {};
-            const getEntryFiles = async (manifest, outputPath)=>{
-                const entryFiles = {};
-                const entries = Object.keys(manifest.entries);
-                for (const entry of entries){
-                    const data = manifest.entries[entry];
-                    entryFiles[entry] = ((data?.initial?.js || []).concat(data?.async?.js || []) || []).map((file)=>dist.Ay.join(outputPath, file));
-                }
-                return entryFiles;
-            };
-            const getRsbuildStats = async ({ environmentName, fileFilters })=>{
-                const stats = await devServer.environments[environmentName].getStats();
-                const enableAssetsCache = (0, memory.i)();
-                const manifest = devServer.environments[environmentName].context.manifest;
-                const { entrypoints, outputPath, assets, hash, chunks } = stats.toJson({
-                    all: false,
-                    hash: true,
-                    entrypoints: true,
-                    outputPath: true,
-                    assets: true,
-                    relatedAssets: true,
-                    cachedAssets: true,
-                    chunks: true,
-                    timings: true
-                });
-                const entryFiles = await getEntryFiles(manifest, outputPath);
-                const entries = [];
-                const setupEntries = [];
-                const sourceEntries = await globTestSourceEntries(environmentName);
-                for (const entry of Object.keys(entrypoints)){
-                    const e = entrypoints[entry];
-                    const distPath = dist.Ay.join(outputPath, e.assets[e.assets.length - 1].name);
-                    if (setupFiles[environmentName][entry]) setupEntries.push({
-                        distPath,
-                        testPath: setupFiles[environmentName][entry],
-                        files: entryFiles[entry],
-                        chunks: e.chunks || []
-                    });
-                    else if (sourceEntries[entry]) {
-                        if (fileFilters?.length && !fileFilters.includes(sourceEntries[entry])) continue;
-                        entries.push({
-                            distPath,
-                            testPath: sourceEntries[entry],
-                            files: entryFiles[entry],
-                            chunks: e.chunks || []
-                        });
-                    }
-                }
-                const inlineSourceMap = 'inline-source-map' === stats.compilation.options.devtool;
-                const sourceMapPaths = Object.fromEntries(assets.map((asset)=>{
-                    const assetFilePath = dist.Ay.join(outputPath, asset.name);
-                    if (inlineSourceMap) return [
-                        assetFilePath,
-                        assetFilePath
-                    ];
-                    const sourceMapPath = asset?.info.related?.sourceMap?.[0];
-                    if (sourceMapPath) {
-                        const filePath = dist.Ay.join(outputPath, sourceMapPath);
-                        return [
-                            assetFilePath,
-                            filePath
-                        ];
-                    }
-                    return [
-                        assetFilePath,
-                        null
-                    ];
-                }));
-                buildData[environmentName] ??= {};
-                const { affectedEntries, deletedEntries } = calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`);
-                const cachedAssetFiles = new AssetsMemorySafeMap();
-                const cachedSourceMaps = new AssetsMemorySafeMap();
-                const readFileWithCache = async (name)=>{
-                    if (enableAssetsCache && cachedAssetFiles.has(name)) return cachedAssetFiles.get(name);
-                    const content = await readFile(name);
-                    enableAssetsCache && cachedAssetFiles.set(name, content);
-                    return content;
-                };
-                const getSourceMap = async (name)=>{
-                    const sourceMapPath = sourceMapPaths[name];
-                    if (!sourceMapPath) return null;
-                    if (enableAssetsCache && cachedSourceMaps.has(name)) return cachedSourceMaps.get(name);
-                    let content = null;
-                    if (inlineSourceMap) {
-                        const file = await readFile(sourceMapPath);
-                        content = parseInlineSourceMapStr(file);
-                    } else {
-                        const sourceMap = await readFile(sourceMapPath);
-                        content = sourceMap;
-                    }
-                    enableAssetsCache && content && cachedSourceMaps.set(name, content);
-                    return content;
-                };
-                const assetNames = assets.map((asset)=>dist.Ay.join(outputPath, asset.name));
-                return {
-                    affectedEntries,
-                    deletedEntries,
-                    hash,
-                    entries,
-                    setupEntries,
-                    assetNames,
-                    getAssetFiles: async (names)=>Object.fromEntries(await Promise.all(names.map(async (name)=>{
-                            const content = await readFileWithCache(name);
-                            return [
-                                name,
-                                content
-                            ];
-                        }))),
-                    getSourceMaps: async (names)=>Object.fromEntries(await Promise.all(names.map(async (name)=>{
-                            const content = await getSourceMap(name);
-                            return [
-                                name,
-                                content
-                            ];
-                        })))
-                };
-            };
-            return {
-                closeServer: devServer.close,
-                getRsbuildStats
-            };
-        };
-    },
-    "./src/pool/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            b: ()=>createPool
-        });
-        var external_node_os_ = __webpack_require__("node:os");
-        var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
-        var utils = __webpack_require__("./src/utils/index.ts");
-        var memory = __webpack_require__("./src/utils/memory.ts");
-        var external_node_url_ = __webpack_require__("node:url");
-        const TYPE_REQUEST = "q";
-        const TYPE_RESPONSE = "s";
-        const DEFAULT_TIMEOUT = 6e4;
-        function defaultSerialize(i) {
-            return i;
-        }
-        const defaultDeserialize = defaultSerialize;
-        const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
-        const random = Math.random.bind(Math);
-        function createBirpc(functions, options) {
-            const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
-            const rpcPromiseMap = /* @__PURE__ */ new Map();
-            let _promise;
-            let closed = false;
-            const rpc = new Proxy({}, {
-                get (_, method) {
-                    if ("$functions" === method) return functions;
-                    if ("$close" === method) return close;
-                    if ("$rejectPendingCalls" === method) return rejectPendingCalls;
-                    if ("$closed" === method) return closed;
-                    if ("then" === method && !eventNames.includes("then") && !("then" in functions)) return;
-                    const sendEvent = (...args)=>{
-                        post(serialize({
-                            m: method,
-                            a: args,
-                            t: TYPE_REQUEST
-                        }));
-                    };
-                    if (eventNames.includes(method)) {
-                        sendEvent.asEvent = sendEvent;
-                        return sendEvent;
-                    }
-                    const sendCall = async (...args)=>{
-                        if (closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-                        if (_promise) try {
-                            await _promise;
-                        } finally{
-                            _promise = void 0;
-                        }
-                        return new Promise((resolve, reject)=>{
-                            const id = nanoid();
-                            let timeoutId;
-                            if (timeout >= 0) {
-                                timeoutId = dist_setTimeout(()=>{
-                                    try {
-                                        const handleResult = options.onTimeoutError?.(method, args);
-                                        if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
-                                    } catch (e) {
-                                        reject(e);
-                                    }
-                                    rpcPromiseMap.delete(id);
-                                }, timeout);
-                                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
-                            }
-                            rpcPromiseMap.set(id, {
-                                resolve,
-                                reject,
-                                timeoutId,
-                                method
-                            });
-                            post(serialize({
-                                m: method,
-                                a: args,
-                                i: id,
-                                t: "q"
-                            }));
-                        });
-                    };
-                    sendCall.asEvent = sendEvent;
-                    return sendCall;
-                }
-            });
-            function close(customError) {
-                closed = true;
-                rpcPromiseMap.forEach(({ reject, method })=>{
-                    const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-                    if (customError) {
-                        customError.cause ??= error;
-                        return reject(customError);
-                    }
-                    reject(error);
-                });
-                rpcPromiseMap.clear();
-                off(onMessage);
-            }
-            function rejectPendingCalls(handler) {
-                const entries = Array.from(rpcPromiseMap.values());
-                const handlerResults = entries.map(({ method, reject })=>{
-                    if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
-                    return handler({
-                        method,
-                        reject
-                    });
-                });
-                rpcPromiseMap.clear();
-                return handlerResults;
-            }
-            async function onMessage(data, ...extra) {
-                let msg;
-                try {
-                    msg = deserialize(data);
-                } catch (e) {
-                    if (options.onGeneralError?.(e) !== true) throw e;
-                    return;
-                }
-                if (msg.t === TYPE_REQUEST) {
-                    const { m: method, a: args } = msg;
-                    let result, error;
-                    const fn = await (resolver ? resolver(method, functions[method]) : functions[method]);
-                    if (fn) try {
-                        result = await fn.apply("rpc" === bind ? rpc : functions, args);
-                    } catch (e) {
-                        error = e;
-                    }
-                    else error = new Error(`[birpc] function "${method}" not found`);
-                    if (msg.i) {
-                        if (error && options.onError) options.onError(error, method, args);
-                        if (error && options.onFunctionError) {
-                            if (true === options.onFunctionError(error, method, args)) return;
-                        }
-                        if (!error) try {
-                            post(serialize({
-                                t: TYPE_RESPONSE,
-                                i: msg.i,
-                                r: result
-                            }), ...extra);
-                            return;
-                        } catch (e) {
-                            error = e;
-                            if (options.onGeneralError?.(e, method, args) !== true) throw e;
-                        }
-                        try {
-                            post(serialize({
-                                t: TYPE_RESPONSE,
-                                i: msg.i,
-                                e: error
-                            }), ...extra);
-                        } catch (e) {
-                            if (options.onGeneralError?.(e, method, args) !== true) throw e;
-                        }
-                    }
-                } else {
-                    const { i: ack, r: result, e: error } = msg;
-                    const promise = rpcPromiseMap.get(ack);
-                    if (promise) {
-                        dist_clearTimeout(promise.timeoutId);
-                        if (error) promise.reject(error);
-                        else promise.resolve(result);
-                    }
-                    rpcPromiseMap.delete(ack);
-                }
-            }
-            _promise = on(onMessage);
-            return rpc;
-        }
-        const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-        function nanoid(size = 21) {
-            let id = "";
-            let i = size;
-            while(i--)id += urlAlphabet[64 * random() | 0];
-            return id;
-        }
-        const forks_filename = (0, external_node_url_.fileURLToPath)(import.meta.url);
-        const forks_dirname = (0, pathe_M_eThtNZ.d)(forks_filename);
-        function createChannel(rpcMethods) {
-            const emitter = new __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__["default"]();
-            const cleanup = ()=>emitter.removeAllListeners();
-            const events = {
-                message: 'message',
-                response: 'response'
-            };
-            const channel = {
-                onMessage: (callback)=>{
-                    emitter.on(events.message, callback);
-                },
-                postMessage: (message)=>{
-                    emitter.emit(events.response, message);
-                }
-            };
-            createBirpc(rpcMethods, {
-                serialize: __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__["default"].serialize,
-                deserialize: (v)=>__WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__["default"].deserialize(Buffer.from(v)),
-                post (v) {
-                    emitter.emit(events.message, v);
-                },
-                on (fn) {
-                    emitter.on(events.response, fn);
-                }
-            });
-            return {
-                channel,
-                cleanup
-            };
-        }
-        const createForksPool = (poolOptions)=>{
-            const { maxWorkers: maxThreads, minWorkers: minThreads, env, execArgv = [], isolate = true } = poolOptions;
-            const options = {
-                runtime: 'child_process',
-                filename: (0, pathe_M_eThtNZ.r)(forks_dirname, './worker.js'),
-                env,
-                execArgv,
-                maxThreads,
-                minThreads,
-                concurrentTasksPerWorker: 1,
-                isolateWorkers: isolate
-            };
-            const pool = new __WEBPACK_EXTERNAL_MODULE_tinypool__.Tinypool(options);
-            return {
-                name: 'forks',
-                runTest: async ({ options, rpcMethods })=>{
-                    const { channel, cleanup } = createChannel(rpcMethods);
-                    try {
-                        return await pool.run(options, {
-                            channel
-                        });
-                    } finally{
-                        cleanup();
-                    }
-                },
-                collectTests: async ({ options, rpcMethods })=>{
-                    const { channel, cleanup } = createChannel(rpcMethods);
-                    try {
-                        return await pool.run(options, {
-                            channel
-                        });
-                    } finally{
-                        cleanup();
-                    }
-                },
-                close: ()=>pool.destroy()
-            };
-        };
-        const getNumCpus = ()=>external_node_os_["default"].availableParallelism?.() ?? external_node_os_["default"].cpus().length;
-        const parseWorkers = (maxWorkers)=>{
-            const parsed = Number.parseInt(maxWorkers.toString(), 10);
-            if ('string' == typeof maxWorkers && maxWorkers.trim().endsWith('%')) {
-                const numCpus = getNumCpus();
-                const workers = Math.floor(parsed / 100 * numCpus);
-                return Math.max(workers, 1);
-            }
-            return parsed > 0 ? parsed : 1;
-        };
-        const getRuntimeConfig = (context)=>{
-            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env } = context.normalizedConfig;
-            return {
-                env,
-                testNamePattern,
-                testTimeout,
-                hookTimeout,
-                passWithNoTests,
-                retry,
-                globals,
-                clearMocks,
-                resetMocks,
-                restoreMocks,
-                unstubEnvs,
-                unstubGlobals,
-                maxConcurrency,
-                printConsoleTrace,
-                disableConsoleIntercept,
-                testEnvironment,
-                isolate,
-                coverage,
-                snapshotFormat
-            };
-        };
-        const filterAssetsByEntry = async (entryInfo, getAssetFiles, getSourceMaps, setupAssets)=>{
-            const assetNames = Array.from(new Set([
-                ...entryInfo.files,
-                ...setupAssets
-            ]));
-            const neededFiles = await getAssetFiles(assetNames);
-            const neededSourceMaps = await getSourceMaps(assetNames);
-            return {
-                assetFiles: neededFiles,
-                sourceMaps: neededSourceMaps
-            };
-        };
-        const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
-            const execArgv = process.execArgv.filter((execArg)=>execArg.startsWith('--perf') || execArg.startsWith('--cpu-prof') || execArg.startsWith('--heap-prof') || execArg.startsWith('--diagnostic-dir'));
-            const numCpus = getNumCpus();
-            const { normalizedConfig: { pool: poolOptions, isolate }, reporters } = context;
-            const threadsCount = 'watch' === context.command ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-            const recommendCount = 'watch' === context.command ? threadsCount : Math.min(recommendWorkerCount, threadsCount);
-            const maxWorkers = poolOptions.maxWorkers ? parseWorkers(poolOptions.maxWorkers) : recommendCount;
-            const minWorkers = poolOptions.minWorkers ? parseWorkers(poolOptions.minWorkers) : maxWorkers < recommendCount ? maxWorkers : recommendCount;
-            if (maxWorkers < minWorkers) throw `Invalid pool configuration: maxWorkers(${maxWorkers}) cannot be less than minWorkers(${minWorkers}).`;
-            const pool = createForksPool({
-                ...poolOptions,
-                isolate,
-                maxWorkers,
-                minWorkers,
-                execArgv: [
-                    ...poolOptions?.execArgv ?? [],
-                    ...execArgv,
-                    '--experimental-vm-modules',
-                    '--experimental-import-meta-resolve',
-                    '--no-warnings',
-                    (0, utils.C3)() ? '--experimental-detect-module' : void 0
-                ].filter(Boolean),
-                env: {
-                    NODE_ENV: 'test',
-                    FORCE_COLOR: '1' === process.env.NO_COLOR ? '0' : '1',
-                    ...process.env
-                }
-            });
-            const rpcMethods = {
-                onTestCaseResult: async (result)=>{
-                    await Promise.all(reporters.map((reporter)=>reporter.onTestCaseResult?.(result)));
-                },
-                onConsoleLog: async (log)=>{
-                    await Promise.all(reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
-                },
-                onTestFileStart: async (test)=>{
-                    await Promise.all(reporters.map((reporter)=>reporter.onTestFileStart?.(test)));
-                },
-                resolveSnapshotPath: (testPath)=>{
-                    const snapExtension = '.snap';
-                    const resolver = context.normalizedConfig.resolveSnapshotPath || (()=>(0, pathe_M_eThtNZ.j)((0, pathe_M_eThtNZ.d)(testPath), '__snapshots__', `${(0, pathe_M_eThtNZ.c)(testPath)}${snapExtension}`));
-                    const snapshotPath = resolver(testPath, snapExtension);
-                    return snapshotPath;
-                }
-            };
-            return {
-                runTests: async ({ entries, getAssetFiles, getSourceMaps, setupEntries, project, updateSnapshot })=>{
-                    const projectName = context.normalizedConfig.name;
-                    const runtimeConfig = getRuntimeConfig(project);
-                    const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
-                    const results = await Promise.all(entries.map(async (entryInfo, index)=>{
-                        const result = await pool.runTest({
-                            options: {
-                                entryInfo,
-                                context: {
-                                    taskId: index + 1,
-                                    project: projectName,
-                                    rootPath: context.rootPath,
-                                    projectRoot: project.rootPath,
-                                    runtimeConfig: (0, utils.Ok)(runtimeConfig)
-                                },
-                                type: 'run',
-                                setupEntries,
-                                updateSnapshot,
-                                assets: (0, memory.i)() ? await filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets) : void 0
-                            },
-                            rpcMethods: {
-                                ...rpcMethods,
-                                getAssetsByEntry: async ()=>filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets)
-                            }
-                        }).catch((err)=>{
-                            err.fullStack = true;
-                            return {
-                                project: projectName,
-                                testPath: entryInfo.testPath,
-                                status: 'fail',
-                                name: '',
-                                results: [],
-                                errors: [
-                                    err
-                                ]
-                            };
-                        });
-                        reporters.map((reporter)=>reporter.onTestFileResult?.(result));
-                        return result;
-                    }));
-                    for (const result of results)if (result.snapshotResult) context.snapshotManager.add(result.snapshotResult);
-                    const testResults = results.flatMap((r)=>r.results);
-                    return {
-                        results,
-                        testResults,
-                        project
-                    };
-                },
-                collectTests: async ({ entries, getAssetFiles, getSourceMaps, setupEntries, project, updateSnapshot })=>{
-                    const runtimeConfig = getRuntimeConfig(project);
-                    const projectName = project.normalizedConfig.name;
-                    const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
-                    return Promise.all(entries.map(async (entryInfo, index)=>pool.collectTests({
-                            options: {
-                                entryInfo,
-                                context: {
-                                    taskId: index + 1,
-                                    project: projectName,
-                                    rootPath: context.rootPath,
-                                    projectRoot: project.rootPath,
-                                    runtimeConfig: (0, utils.Ok)(runtimeConfig)
-                                },
-                                type: 'collect',
-                                setupEntries,
-                                updateSnapshot,
-                                assets: (0, memory.i)() ? await filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets) : void 0
-                            },
-                            rpcMethods: {
-                                ...rpcMethods,
-                                getAssetsByEntry: async ()=>filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets)
-                            }
-                        }).catch((err)=>{
-                            err.fullStack = true;
-                            return {
-                                project: projectName,
-                                testPath: entryInfo.testPath,
-                                tests: [],
-                                errors: [
-                                    err
-                                ]
-                            };
-                        })));
-                },
-                close: ()=>pool.close()
-            };
-        };
-    },
-    "./src/utils/memory.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            i: ()=>isMemorySufficient
-        });
-        var node_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:process");
-        const DefaultMaxHeapSize = 1073741824;
-        function isMemorySufficient(options) {
-            const { memoryThreshold = 0.7, maxHeapSize = DefaultMaxHeapSize } = options || {};
-            if (!node_process__WEBPACK_IMPORTED_MODULE_0__["default"]?.memoryUsage) return true;
-            const memoryUsage = node_process__WEBPACK_IMPORTED_MODULE_0__["default"].memoryUsage();
-            const heapUsed = memoryUsage.heapUsed;
-            const heapTotal = memoryUsage.heapTotal;
-            const memoryUsageRatio = heapUsed / heapTotal;
-            const isMemorySufficient = memoryUsageRatio < memoryThreshold && heapUsed < maxHeapSize;
-            return isMemorySufficient;
-        }
-    },
-    "node:url": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__;
-    }
-};