@rstest/core 0.0.4 → 0.0.6

package/dist/{992.js → 612.js}

@@ -1,5 +1,5 @@
 export const __webpack_ids__ = [
-    "992"
+    "612"
 ];
 export const __webpack_modules__ = {
     "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -11,6 +11,38 @@ export const __webpack_modules__ = {
         var core_ = __webpack_require__("@rsbuild/core");
         var external_pathe_ = __webpack_require__("pathe");
         var utils = __webpack_require__("./src/utils/index.ts");
+        var external_node_path_ = __webpack_require__("node:path");
+        var external_node_url_ = __webpack_require__("node:url");
+        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){
@@ -47,8 +79,8 @@ export const __webpack_modules__ = {
                             config.watchOptions.ignored = '**/**';
                             const sourceEntries = await globTestSourceEntries();
                             config.entry = {
-                                ...sourceEntries,
-                                ...setupFiles
+                                ...setupFiles,
+                                ...sourceEntries
                             };
                         }
                     });
@@ -73,12 +105,155 @@ export const __webpack_modules__ = {
                 });
             }
         };
+        class MockRuntimeRspackPlugin {
+            apply(compiler) {
+                const { RuntimeModule } = compiler.webpack;
+                class RetestImportRuntimeModule extends RuntimeModule {
+                    constructor(){
+                        super('rstest runtime');
+                    }
+                    generate() {
+                        return `
+if (typeof __webpack_require__ === 'undefined') {
+  return;
+}
+
+const originalRequire = __webpack_require__;
+__webpack_require__ = function(...args) {
+  try {
+    return originalRequire(...args);
+  } catch (e) {
+    const errMsg = e.message ?? e.toString();
+    if (errMsg.includes('__webpack_modules__[moduleId] is not a function')) {
+      throw new Error(\`Cannot find module '\${args[0]}'\`)
+    }
+    throw e;
+  }
+};
+
+Object.keys(originalRequire).forEach(key => {
+  __webpack_require__[key] = originalRequire[key];
+});
+
+__webpack_require__.rstest_original_modules = {};
+
+// TODO: Remove "reset_modules" in next Rspack version.
+__webpack_require__.rstest_reset_modules = __webpack_require__.reset_modules = () => {
+  const mockedIds = Object.keys(__webpack_require__.rstest_original_modules)
+  Object.keys(__webpack_module_cache__).forEach(id => {
+    // Do not reset mocks registry.
+    if (!mockedIds.includes(id)) {
+      delete __webpack_module_cache__[id];
+    }
+  });
+}
+
+// TODO: Remove "unmock" in next Rspack version.
+__webpack_require__.rstest_unmock = __webpack_require__.unmock = (id) => {
+  delete __webpack_module_cache__[id]
+}
+
+// TODO: Remove "require_actual" and "import_actual" in next Rspack version.
+__webpack_require__.rstest_require_actual = __webpack_require__.rstest_import_actual = __webpack_require__.require_actual = __webpack_require__.import_actual = (id) => {
+  const originalModule = __webpack_require__.rstest_original_modules[id];
+  // Use fallback module if the module is not mocked.
+  const fallbackMod = __webpack_require__(id);
+  return originalModule ? originalModule : fallbackMod;
+}
+
+// TODO: Remove "set_mock" in next Rspack version.
+__webpack_require__.rstest_set_mock = __webpack_require__.set_mock = (id, modFactory) => {
+  let requiredModule = undefined
+  try {
+    requiredModule = __webpack_require__(id);
+  } catch {
+    // TODO: non-resolved module
+  } finally {
+    __webpack_require__.rstest_original_modules[id] = requiredModule;
+  }
+  if (typeof modFactory === 'string' || typeof modFactory === 'number') {
+    __webpack_module_cache__[id] = { exports: __webpack_require__(modFactory) };
+  } else if (typeof modFactory === 'function') {
+    let exports = modFactory();
+    __webpack_require__.r(exports);
+    __webpack_module_cache__[id] = { exports, id, loaded: true };
+  }
+};
+`;
+                    }
+                }
+                compiler.hooks.thisCompilation.tap('CustomPlugin', (compilation)=>{
+                    compilation.hooks.additionalTreeRuntimeRequirements.tap('CustomPlugin', (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('CustomPlugin', (compilation)=>{
+                    compilation.hooks.additionalTreeRuntimeRequirements.tap('CustomPlugin', (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 isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
         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' : 'module-import');
+                callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : 'import');
             };
             const resolver = getResolve?.();
             if (!resolver) return callback();
@@ -98,7 +273,7 @@ export const __webpack_modules__ = {
             else callback();
         };
         const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
-            const { command, normalizedConfig: { name, plugins, resolve, source, output, tools, testEnvironment, performance, dev = {} } } = context;
+            const { command, normalizedConfig: { isolate, name, plugins, resolve, source, output, tools, testEnvironment, performance, dev = {} } } = context;
             const debugMode = (0, utils.L1)();
             core_.logger.level = debugMode ? 'verbose' : 'error';
             const writeToDisk = dev.writeToDisk || debugMode;
@@ -112,7 +287,13 @@ export const __webpack_modules__ = {
                     server: {
                         printUrls: false,
                         strictPort: false,
-                        middlewareMode: true
+                        middlewareMode: true,
+                        compress: false,
+                        cors: false,
+                        publicDir: false
+                    },
+                    dev: {
+                        hmr: false
                     },
                     performance,
                     environments: {
@@ -143,9 +324,9 @@ export const __webpack_modules__ = {
                                     config.output.devtoolModuleFilenameTemplate = '[absolute-resource-path]';
                                     config.plugins.push(new core_.rspack.experiments.RstestPlugin({
                                         injectModulePathName: true,
-                                        hoistMockModule: true,
                                         importMetaPathName: true,
-                                        manualMockRoot: context.rootPath
+                                        hoistMockModule: true,
+                                        manualMockRoot: external_pathe_["default"].resolve(context.rootPath, '__mocks__')
                                     }));
                                     config.externals = (0, utils.XQ)(config.externals) || [];
                                     config.externals.unshift({
@@ -162,12 +343,12 @@ export const __webpack_modules__ = {
                                         requireAsExpression: false,
                                         ...config.module.parser.javascript || {}
                                     };
-                                    if ('node' === testEnvironment && ((0, utils.mP)()[0] || 0) < 20) {
-                                        config.resolve ??= {};
-                                        config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
-                                            'main'
-                                        ];
-                                    }
+                                    config.resolve ??= {};
+                                    config.resolve.extensions ??= [];
+                                    config.resolve.extensions.push('.cjs');
+                                    if ('node' === testEnvironment && (0, utils.mP)().major < 20) config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
+                                        'main'
+                                    ];
                                     config.optimization = {
                                         moduleIds: 'named',
                                         chunkIds: 'named',
@@ -180,6 +361,8 @@ export const __webpack_modules__ = {
                             },
                             plugins: [
                                 pluginIgnoreResolveError,
+                                pluginMockRuntime,
+                                pluginCSSFilter(),
                                 pluginEntryWatch({
                                     globTestSourceEntries,
                                     setupFiles,
@@ -190,6 +373,9 @@ export const __webpack_modules__ = {
                     }
                 }
             });
+            if (!isolate) rsbuildInstance.addPlugins([
+                pluginCacheControl(Object.values(setupFiles))
+            ]);
             return rsbuildInstance;
         };
         const createRsbuildServer = async ({ name, globTestSourceEntries, setupFiles, rsbuildInstance, normalizedConfig })=>{
@@ -405,8 +591,9 @@ export const __webpack_modules__ = {
                     ...execArgv,
                     '--experimental-vm-modules',
                     '--experimental-import-meta-resolve',
-                    '--no-warnings'
-                ],
+                    '--no-warnings',
+                    (0, utils.PA)() ? '--experimental-detect-module' : void 0
+                ].filter(Boolean),
                 env: {
                     NODE_ENV: 'test',
                     FORCE_COLOR: '1',
@@ -414,10 +601,11 @@ export const __webpack_modules__ = {
                 }
             });
             const { updateSnapshot } = context.snapshotManager.options;
-            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment } = context.normalizedConfig;
+            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout } = context.normalizedConfig;
             const runtimeConfig = {
                 testNamePattern,
                 testTimeout,
+                hookTimeout,
                 passWithNoTests,
                 retry,
                 globals,
@@ -429,7 +617,8 @@ export const __webpack_modules__ = {
                 maxConcurrency,
                 printConsoleTrace,
                 disableConsoleIntercept,
-                testEnvironment
+                testEnvironment,
+                isolate
             };
             const rpcMethods = {
                 onTestCaseResult: async (result)=>{

package/dist/{502.js → 723.js}

@@ -1,8 +1,8 @@
 export const __webpack_ids__ = [
-    "502"
+    "723"
 ];
 export const __webpack_modules__ = {
-    "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.27/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+    "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.29/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             s7: ()=>TraceMap,
             Sk: ()=>originalPositionFor

package/dist/867.js

@@ -927,11 +927,12 @@ export const __webpack_modules__ = {
             testPath;
             collectStatus = 'lazy';
             currentCollectList = [];
-            defaultHookTimeout = 5000;
+            defaultHookTimeout;
             defaultTestTimeout;
-            constructor({ testPath, testTimeout }){
+            constructor({ testPath, testTimeout, hookTimeout }){
                 this.testPath = testPath;
                 this.defaultTestTimeout = testTimeout;
+                this.defaultHookTimeout = hookTimeout;
             }
             afterAll(fn, timeout = this.defaultHookTimeout) {
                 const currentSuite = this.getCurrentSuite();
@@ -1139,10 +1140,11 @@ export const __webpack_modules__ = {
                 throw new Error('Expect to find a suite, but got undefined');
             }
         }
-        const createRuntimeAPI = ({ testPath, testTimeout })=>{
+        const createRuntimeAPI = ({ testPath, testTimeout, hookTimeout })=>{
             const runtimeInstance = new RunnerRuntime({
                 testPath,
-                testTimeout
+                testTimeout,
+                hookTimeout
             });
             const createTestAPI = (options = {})=>{
                 const testFn = (name, fn, timeout)=>runtimeInstance.it({
@@ -1290,10 +1292,11 @@ export const __webpack_modules__ = {
             };
         };
         function createRunner({ workerState }) {
-            const { testPath, runtimeConfig: { testTimeout, testNamePattern } } = workerState;
+            const { testPath, runtimeConfig: { testTimeout, testNamePattern, hookTimeout } } = workerState;
             const runtime = createRuntimeAPI({
                 testPath,
-                testTimeout
+                testTimeout,
+                hookTimeout
             });
             const testRunner = new TestRunner();
             return {
@@ -1594,10 +1597,13 @@ export const __webpack_modules__ = {
                     return rstest;
                 },
                 mock: ()=>{},
+                mockRequire: ()=>{},
                 doMock: ()=>{},
-                unMock: ()=>{},
-                doUnMock: ()=>{},
+                doMockRequire: ()=>{},
+                unmock: ()=>{},
+                doUnmock: ()=>{},
                 importMock: async ()=>({}),
+                requireMock: ()=>({}),
                 importActual: async ()=>({}),
                 requireActual: ()=>({}),
                 resetModules: ()=>rstest,

package/dist/{202.js → 965.js}

@@ -1,11 +1,48 @@
 export const __webpack_ids__ = [
-    "202"
+    "965"
 ];
 export const __webpack_modules__ = {
     "./src/runtime/worker/env/jsdom.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             environment: ()=>environment
         });
+        var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/runtime/worker/env/utils.ts");
+        const environment = {
+            name: 'jsdom',
+            async setup (global, { jsdom = {} }) {
+                const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import("jsdom");
+                const { html = '<!DOCTYPE html>', userAgent, url = 'http://localhost:3000', contentType = 'text/html', pretendToBeVisual = true, includeNodeLocations = false, runScripts = 'dangerously', resources, console = false, cookieJar = false, ...restOptions } = jsdom;
+                const dom = new JSDOM(html, {
+                    pretendToBeVisual,
+                    resources: resources ?? (userAgent ? new ResourceLoader({
+                        userAgent
+                    }) : void 0),
+                    runScripts,
+                    url,
+                    virtualConsole: console && global.console ? new VirtualConsole().sendTo(global.console) : void 0,
+                    cookieJar: cookieJar ? new CookieJar() : void 0,
+                    includeNodeLocations,
+                    contentType,
+                    userAgent,
+                    ...restOptions
+                });
+                const cleanupGlobal = (0, _utils__WEBPACK_IMPORTED_MODULE_0__.Nc)(global, dom.window);
+                const cleanupHandler = (0, _utils__WEBPACK_IMPORTED_MODULE_0__.xp)(global);
+                return {
+                    teardown () {
+                        cleanupHandler();
+                        dom.window.close();
+                        cleanupGlobal();
+                    }
+                };
+            }
+        };
+    },
+    "./src/runtime/worker/env/utils.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            xp: ()=>addDefaultErrorHandler,
+            Nc: ()=>installGlobal
+        });
         const LIVING_KEYS = [
             'DOMException',
             'URL',
@@ -273,13 +310,16 @@ export const __webpack_modules__ = {
                 return true;
             }));
         }
+        function isClassLike(name) {
+            return name[0] === name[0]?.toUpperCase();
+        }
         function installGlobal(global, win, options = {}) {
+            const { bindFunctions = true } = options || {};
             const keys = getWindowKeys(global, win, options.additionalKeys);
-            const isClassLike = (name)=>name[0] === name[0]?.toUpperCase();
             const originals = new Map();
             const overrides = new Map();
             for (const key of keys){
-                const boundFunction = 'function' != typeof win[key] || isClassLike(key) ? void 0 : win[key].bind(win);
+                const boundFunction = bindFunctions && 'function' == typeof win[key] && !isClassLike(key) && win[key].bind(win);
                 if (key in global) originals.set(key, global[key]);
                 Object.defineProperty(global, key, {
                     get () {
@@ -331,35 +371,5 @@ export const __webpack_modules__ = {
                 window.removeEventListener('error', throwUnhandledError);
             };
         }
-        const environment = {
-            name: 'jsdom',
-            async setup (global, { jsdom = {} }) {
-                const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import("jsdom");
-                const { html = '<!DOCTYPE html>', userAgent, url = 'http://localhost:3000', contentType = 'text/html', pretendToBeVisual = true, includeNodeLocations = false, runScripts = 'dangerously', resources, console = false, cookieJar = false, ...restOptions } = jsdom;
-                const dom = new JSDOM(html, {
-                    pretendToBeVisual,
-                    resources: resources ?? (userAgent ? new ResourceLoader({
-                        userAgent
-                    }) : void 0),
-                    runScripts,
-                    url,
-                    virtualConsole: console && global.console ? new VirtualConsole().sendTo(global.console) : void 0,
-                    cookieJar: cookieJar ? new CookieJar() : void 0,
-                    includeNodeLocations,
-                    contentType,
-                    userAgent,
-                    ...restOptions
-                });
-                const cleanupGlobal = installGlobal(global, dom.window);
-                const cleanupHandler = addDefaultErrorHandler(global);
-                return {
-                    teardown () {
-                        cleanupHandler();
-                        dom.window.close();
-                        cleanupGlobal();
-                    }
-                };
-            }
-        };
     }
 };

package/dist/cli.js

@@ -2238,6 +2238,7 @@ var __webpack_modules__ = {
                 passWithNoTests: false,
                 update: false,
                 testTimeout: 5000,
+                hookTimeout: 10000,
                 testEnvironment: 'node',
                 retry: 0,
                 reporters: [
@@ -2292,6 +2293,7 @@ var __webpack_modules__ = {
             $_: ()=>picocolors__WEBPACK_IMPORTED_MODULE_2___default.a,
             AS: ()=>prettyTime,
             H: ()=>parsePosix,
+            PA: ()=>needFlagExperimentalDetectModule,
             Tn: ()=>NODE_BUILTINS,
             XQ: ()=>castArray,
             Yz: ()=>getTaskNameWithPrefix,
@@ -2331,18 +2333,23 @@ var __webpack_modules__ = {
             }
             return String(error);
         }
-        const prettyTime = (milliseconds, shouldFormat = true)=>{
-            const format = (time)=>shouldFormat ? picocolors__WEBPACK_IMPORTED_MODULE_2___default().bold(time) : time;
-            const indent = shouldFormat ? ' ' : '';
-            if (milliseconds < 1000) return `${Math.round(milliseconds)}${indent}ms`;
+        const prettyTime = (milliseconds)=>{
+            if (milliseconds < 1000) return `${Math.round(milliseconds)}ms`;
             const seconds = milliseconds / 1000;
-            if (seconds < 10) {
-                const digits = seconds >= 0.01 ? 2 : 3;
-                return `${format(seconds.toFixed(digits))}${indent}s`;
+            const getSecond = (seconds, needDigits)=>{
+                if (!needDigits || seconds === Math.ceil(seconds)) return `${Math.round(seconds).toString()}s`;
+                const digits = seconds < 10 ? seconds >= 0.01 ? 2 : 3 : 1;
+                return `${seconds.toFixed(digits)}s`;
+            };
+            const minutes = Math.floor(seconds / 60);
+            const secondsRemainder = seconds % 60;
+            let time = '';
+            if (minutes > 0) time += `${minutes}m`;
+            if (secondsRemainder > 0) {
+                if (minutes > 0) time += ' ';
+                time += getSecond(secondsRemainder, !minutes);
             }
-            if (seconds < 60) return `${format(seconds.toFixed(1))}${indent}s`;
-            const minutes = seconds / 60;
-            return `${format(minutes.toFixed(2))}${indent}m`;
+            return time;
         };
         const getTaskNames = (test)=>(test.parentNames || []).concat(test.name).filter(Boolean);
         const getTaskNameWithPrefix = (test, delimiter = _constants__WEBPACK_IMPORTED_MODULE_1__.Qd)=>getTaskNames(test).join(` ${delimiter} `);
@@ -2355,11 +2362,27 @@ var __webpack_modules__ = {
                 testNamePattern: testNamePattern && 'string' != typeof testNamePattern ? wrapRegex(testNamePattern) : testNamePattern
             };
         };
-        const getNodeVersion = ()=>'string' == typeof process.versions?.node ? process.versions.node.split('.').map(Number) : [
-                0,
-                0,
-                0
-            ];
+        const getNodeVersion = ()=>{
+            if ('string' == typeof process.versions?.node) {
+                const [major = 0, minor = 0, patch = 0] = process.versions.node.split('.').map(Number);
+                return {
+                    major,
+                    minor,
+                    patch
+                };
+            }
+            return {
+                major: 0,
+                minor: 0,
+                patch: 0
+            };
+        };
+        const needFlagExperimentalDetectModule = ()=>{
+            const { major, minor } = getNodeVersion();
+            if (20 === major && minor >= 10) return true;
+            if (22 === major && minor < 7) return true;
+            return false;
+        };
         const NODE_BUILTINS = [
             'assert',
             'assert/strict',
@@ -2434,6 +2457,7 @@ var __webpack_modules__ = {
             Tn: ()=>helper.Tn,
             $_: ()=>helper.$_,
             Yz: ()=>helper.Yz,
+            PA: ()=>helper.PA,
             L1: ()=>logger.L,
             v8: ()=>helper.v8,
             Qd: ()=>constants.Qd,
@@ -3647,13 +3671,13 @@ function prepareCli() {
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
 }
 function showRstest() {
-    logger.k.greet("  Rstest v0.0.4");
+    logger.k.greet("  Rstest v0.0.6");
     logger.k.log('');
 }
 const applyCommonOptions = (cli)=>{
     cli.option('-c, --config <config>', 'Specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'Specify the loader to load the config file, can be `jiti` or `native`', {
         default: 'jiti'
-    }).option('-r, --root <root>', 'Specify the project root directory, can be an absolute path or a path relative to cwd').option('--globals', 'Provide global APIs').option('-u, --update', 'Update snapshot files').option('--passWithNoTests', 'Allows the test suite to pass when no files are found').option('--printConsoleTrace', 'Print console traces when calling any console method').option('--disableConsoleIntercept', 'Disable console intercept').option('--slowTestThreshold <value>', 'The number of milliseconds after which a test or suite is considered slow').option('-t, --testNamePattern <value>', 'Run only tests with a name that matches the regex').option('--testEnvironment <name>', 'The environment that will be used for testing').option('--testTimeout <value>', 'Timeout of a test in milliseconds').option('--retry <retry>', 'Number of times to retry a test if it fails').option('--maxConcurrency <value>', 'Maximum number of concurrent tests').option('--clearMocks', 'Automatically clear mock calls, instances, contexts and results before every test').option('--resetMocks', 'Automatically reset mock state before every test').option('--restoreMocks', 'Automatically restore mock state and implementation before every test').option('--unstubGlobals', 'Restores all global variables that were changed with `rstest.stubGlobal` before every test').option('--unstubEnvs', 'Restores all `process.env` values that were changed with `rstest.stubEnv` before every test');
+    }).option('-r, --root <root>', 'Specify the project root directory, can be an absolute path or a path relative to cwd').option('--globals', 'Provide global APIs').option('--isolate', 'Run tests in an isolated environment').option('--exclude <exclude>', 'Exclude files from test').option('-u, --update', 'Update snapshot files').option('--passWithNoTests', 'Allows the test suite to pass when no files are found').option('--printConsoleTrace', 'Print console traces when calling any console method').option('--disableConsoleIntercept', 'Disable console intercept').option('--slowTestThreshold <value>', 'The number of milliseconds after which a test or suite is considered slow').option('-t, --testNamePattern <value>', 'Run only tests with a name that matches the regex').option('--testEnvironment <name>', 'The environment that will be used for testing').option('--testTimeout <value>', 'Timeout of a test in milliseconds').option('--hookTimeout <value>', 'Timeout of hook in milliseconds').option('--retry <retry>', 'Number of times to retry a test if it fails').option('--maxConcurrency <value>', 'Maximum number of concurrent tests').option('--clearMocks', 'Automatically clear mock calls, instances, contexts and results before every test').option('--resetMocks', 'Automatically reset mock state before every test').option('--restoreMocks', 'Automatically restore mock state and implementation before every test').option('--unstubGlobals', 'Restores all global variables that were changed with `rstest.stubGlobal` before every test').option('--unstubEnvs', 'Restores all `process.env` values that were changed with `rstest.stubEnv` before every test');
 };
 async function initCli(options) {
     const cwd = process.cwd();
@@ -3666,10 +3690,12 @@ async function initCli(options) {
     const keys = [
         'root',
         'globals',
+        'isolate',
         'passWithNoTests',
         'update',
         'testNamePattern',
         'testTimeout',
+        'hookTimeout',
         'clearMocks',
         'resetMocks',
         'restoreMocks',
@@ -3683,6 +3709,7 @@ async function initCli(options) {
         'testEnvironment'
     ];
     for (const key of keys)if (void 0 !== options[key]) config[key] = options[key];
+    if (options.exclude) config.exclude = (0, helper.XQ)(options.exclude);
     return {
         config,
         configFilePath
@@ -3691,7 +3718,7 @@ async function initCli(options) {
 function setupCommands() {
     const cli = dist('rstest');
     cli.help();
-    cli.version("0.0.4");
+    cli.version("0.0.6");
     applyCommonOptions(cli);
     cli.command('[...filters]', 'run tests').action(async (filters, options)=>{
         showRstest();

package/dist/cssFilterLoader.mjs

@@ -0,0 +1,22 @@
+const CSS_MODULES_REGEX = /\.module\.\w+$/i;
+const isCSSModules = ({ resourcePath, resourceQuery, resourceFragment, modules })=>{
+    if ('boolean' == typeof modules) return modules;
+    if ('string' == typeof modules) return 'global' !== modules;
+    const { auto } = modules;
+    if ('boolean' == typeof auto) return auto && CSS_MODULES_REGEX.test(resourcePath);
+    if (auto instanceof RegExp) return auto.test(resourcePath);
+    if ('function' == typeof auto) return auto(resourcePath, resourceQuery, resourceFragment);
+    return true;
+};
+function loader(content) {
+    const { resourcePath, resourceQuery, resourceFragment } = this;
+    const { modules = true } = this.getOptions() || {};
+    if (isCSSModules({
+        resourcePath,
+        resourceQuery,
+        resourceFragment,
+        modules
+    })) return content;
+    return '';
+}
+export { loader as default };