@rspack/test-tools 2.0.1 → 2.0.3

package/dist/runner/node/index.js

@@ -1,471 +1,405 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+var __webpack_modules__ = {
+    "@rspack/test-tools" (module) {
+        module.exports = require("@rspack/test-tools");
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeRunner = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_url_1 = require("node:url");
-const node_vm_1 = __importStar(require("node:vm"));
-const config_1 = require("../../case/config");
-const asModule_1 = __importDefault(require("../../helper/legacy/asModule"));
-const createFakeWorker_1 = __importDefault(require("../../helper/legacy/createFakeWorker"));
-const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
-const type_1 = require("../../type");
-const isRelativePath = (p) => /^\.\.?\//.test(p);
-const getSubPath = (p) => {
-    const lastSlash = p.lastIndexOf('/');
-    let firstSlash = p.indexOf('/');
-    if (lastSlash !== -1 && firstSlash !== lastSlash) {
-        if (firstSlash !== -1) {
-            let next = p.indexOf('/', firstSlash + 1);
-            let dir = p.slice(firstSlash + 1, next);
-            while (dir === '.') {
-                firstSlash = next;
-                next = p.indexOf('/', firstSlash + 1);
-                dir = p.slice(firstSlash + 1, next);
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        NodeRunner: ()=>NodeRunner
+    });
+    const external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+    const external_node_url_namespaceObject = require("node:url");
+    const external_node_vm_namespaceObject = require("node:vm");
+    var external_node_vm_default = /*#__PURE__*/ __webpack_require__.n(external_node_vm_namespaceObject);
+    const config_js_namespaceObject = require("../../case/config.js");
+    const asModule_js_namespaceObject = require("../../helper/legacy/asModule.js");
+    const createFakeWorker_js_namespaceObject = require("../../helper/legacy/createFakeWorker.js");
+    const urlToRelativePath_js_namespaceObject = require("../../helper/legacy/urlToRelativePath.js");
+    const external_type_js_namespaceObject = require("../../type.js");
+    const isRelativePath = (p)=>/^\.\.?\//.test(p);
+    const getSubPath = (p)=>{
+        const lastSlash = p.lastIndexOf('/');
+        let firstSlash = p.indexOf('/');
+        if (-1 !== lastSlash && firstSlash !== lastSlash) {
+            if (-1 !== firstSlash) {
+                let next = p.indexOf('/', firstSlash + 1);
+                let dir = p.slice(firstSlash + 1, next);
+                while('.' === dir){
+                    firstSlash = next;
+                    next = p.indexOf('/', firstSlash + 1);
+                    dir = p.slice(firstSlash + 1, next);
+                }
             }
+            return p.slice(firstSlash + 1, lastSlash + 1);
         }
-        return p.slice(firstSlash + 1, lastSlash + 1);
-    }
-    return '';
-};
-const cached = new Map();
-class NodeRunner {
-    constructor(_options) {
-        this._options = _options;
-        this.requireCache = Object.create(null);
-        this.globalContext = null;
-        this.baseModuleScope = null;
-        this.requirers = new Map();
-    }
-    log(message) {
-        this._options.logs?.push(`[NodeRunner] ${message}`);
-    }
-    run(file) {
-        if (!this.globalContext) {
-            this.globalContext = this.createGlobalContext();
+        return '';
+    };
+    const cached = new Map();
+    class NodeRunner {
+        _options;
+        requireCache = Object.create(null);
+        globalContext = null;
+        baseModuleScope = null;
+        requirers = new Map();
+        constructor(_options){
+            this._options = _options;
         }
-        this.baseModuleScope = this.createBaseModuleScope();
-        if (typeof this._options.testConfig.moduleScope === 'function') {
-            this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);
+        log(message) {
+            this._options.logs?.push(`[NodeRunner] ${message}`);
         }
-        this.createRunner();
-        const res = this.getRequire()(node_path_1.default.isAbsolute(file) ? node_path_1.default.dirname(file) : this._options.dist, file.startsWith('./') ||
-            file.startsWith('https://test.cases/') ||
-            node_path_1.default.isAbsolute(file)
-            ? file
-            : `./${file}`);
-        if (this.globalContext.WAITING.length) {
-            return Promise.all(this.globalContext.WAITING).then(() => res);
+        run(file) {
+            if (!this.globalContext) this.globalContext = this.createGlobalContext();
+            this.baseModuleScope = this.createBaseModuleScope();
+            if ('function' == typeof this._options.testConfig.moduleScope) this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);
+            this.createRunner();
+            const res = this.getRequire()(external_node_path_default().isAbsolute(file) ? external_node_path_default().dirname(file) : this._options.dist, file.startsWith('./') || file.startsWith('https://test.cases/') || external_node_path_default().isAbsolute(file) ? file : `./${file}`);
+            if (this.globalContext.WAITING.length) return Promise.all(this.globalContext.WAITING).then(()=>res);
+            if ('object' == typeof res && 'then' in res) return res;
+            return Promise.resolve(res);
         }
-        if (typeof res === 'object' && 'then' in res) {
-            return res;
+        getRequire() {
+            const entryRequire = this.requirers.get('entry');
+            const runner = this;
+            return function(currentDirectory, modulePath, context = {}) {
+                const from = this?.from;
+                if (from) runner.log(`require: ${modulePath} from ${from}`);
+                else runner.log(`require: ${modulePath}`);
+                const p = Array.isArray(modulePath) ? modulePath : modulePath.split('?')[0];
+                return entryRequire(currentDirectory, p, context);
+            };
         }
-        return Promise.resolve(res);
-    }
-    getRequire() {
-        const entryRequire = this.requirers.get('entry');
-        const runner = this;
-        return function (currentDirectory, modulePath, context = {}) {
-            const from = this?.from;
-            if (from) {
-                runner.log(`require: ${modulePath} from ${from}`);
-            }
-            else {
-                runner.log(`require: ${modulePath}`);
-            }
-            const p = Array.isArray(modulePath)
-                ? modulePath
-                : modulePath.split('?')[0];
-            return entryRequire(currentDirectory, p, context);
-        };
-    }
-    getGlobal(name) {
-        return (this.globalContext || {})[name];
-    }
-    createGlobalContext() {
-        return {
-            console: {
-                log: (...args) => {
-                    if (printLogger) {
-                        console.log(...args);
-                    }
-                },
-                warn: (...args) => {
-                    if (printLogger) {
-                        console.warn(...args);
-                    }
-                },
-                error: (...args) => {
-                    console.error(...args);
-                },
-                info: (...args) => {
-                    if (printLogger) {
-                        console.info(...args);
-                    }
-                },
-                debug: (...args) => {
-                    if (printLogger) {
-                        console.info(...args);
-                    }
-                },
-                trace: (...args) => {
-                    if (printLogger) {
-                        console.info(...args);
+        getGlobal(name) {
+            return (this.globalContext || {})[name];
+        }
+        createGlobalContext() {
+            return {
+                console: {
+                    log: (...args)=>{
+                        if (printLogger) console.log(...args);
+                    },
+                    warn: (...args)=>{
+                        if (printLogger) console.warn(...args);
+                    },
+                    error: (...args)=>{
+                        console.error(...args);
+                    },
+                    info: (...args)=>{
+                        if (printLogger) console.info(...args);
+                    },
+                    debug: (...args)=>{
+                        if (printLogger) console.info(...args);
+                    },
+                    trace: (...args)=>{
+                        if (printLogger) console.info(...args);
+                    },
+                    assert: (...args)=>{
+                        console.assert(...args);
+                    },
+                    clear: ()=>{
+                        console.clear();
                     }
                 },
-                assert: (...args) => {
-                    console.assert(...args);
-                },
-                clear: () => {
-                    console.clear();
+                WAITING: [],
+                setTimeout: (cb, ms, ...args)=>{
+                    const timeout = setTimeout(cb, ms, ...args);
+                    timeout.unref();
+                    return timeout;
                 },
-            },
-            WAITING: [],
-            setTimeout: ((cb, ms, ...args) => {
-                const timeout = setTimeout(cb, ms, ...args);
-                timeout.unref();
-                return timeout;
-            }),
-            clearTimeout: clearTimeout,
-        };
-    }
-    createBaseModuleScope() {
-        const baseModuleScope = {
-            console: this.globalContext.console,
-            setTimeout: this.globalContext.setTimeout,
-            clearTimeout: this.globalContext.clearTimeout,
-            nsObj: (m) => {
-                Object.defineProperty(m, Symbol.toStringTag, {
-                    value: 'Module',
-                });
-                return m;
-            },
-            WAITING: this.globalContext.WAITING,
-            process,
-            TextDecoder,
-            URL,
-            Blob,
-            Symbol,
-            Buffer,
-            setImmediate,
-            self: this.globalContext,
-            __TEST_PATH__: __TEST_PATH__,
-            __TEST_SOURCE_PATH__: this._options.source,
-            __TEST_DIST_PATH__: this._options.dist,
-            __MODE__: this._options.compilerOptions.mode,
-            __SNAPSHOT__: node_path_1.default.join(this._options.source, '__snapshot__'),
-            Worker: (0, createFakeWorker_1.default)(this._options.env, {
-                outputDirectory: this._options.dist,
-            }),
-            ...this._options.env,
-        };
-        return baseModuleScope;
-    }
-    createModuleScope(requireFn, m, file) {
-        const requirer = requireFn.bind({
-            from: file.path,
-            module: m,
-        }, node_path_1.default.dirname(file.path));
-        requirer.webpackTestSuiteRequire = true;
-        return {
-            ...this.baseModuleScope,
-            require: requirer,
-            module: m,
-            exports: m.exports,
-            __dirname: node_path_1.default.dirname(file.path),
-            __filename: file.path,
-            _globalAssign: {
-                expect: this._options.env.expect,
-            },
-        };
-    }
-    getFile(modulePath, currentDirectory) {
-        const cacheKey = `${currentDirectory}|${modulePath}`;
-        if (this._options.cachable && cached.has(cacheKey)) {
-            return cached.get(cacheKey);
-        }
-        let res = null;
-        if (Array.isArray(modulePath)) {
-            res = {
-                path: node_path_1.default.join(currentDirectory, '.array-require.js'),
-                content: `module.exports = (${modulePath
-                    .map((arg) => {
-                    return `require(${JSON.stringify(`./${arg}`)})`;
-                })
-                    .join(', ')});`,
-                subPath: '',
+                clearTimeout: clearTimeout
             };
         }
-        else if (modulePath.startsWith('https://test.cases/')) {
-            const relativePath = (0, urlToRelativePath_1.default)(modulePath);
-            const absPath = node_path_1.default.join(currentDirectory, relativePath);
-            res = {
-                path: absPath,
-                content: node_fs_1.default.readFileSync(absPath, 'utf-8'),
-                subPath: '',
+        createBaseModuleScope() {
+            const baseModuleScope = {
+                console: this.globalContext.console,
+                setTimeout: this.globalContext.setTimeout,
+                clearTimeout: this.globalContext.clearTimeout,
+                nsObj: (m)=>{
+                    Object.defineProperty(m, Symbol.toStringTag, {
+                        value: 'Module'
+                    });
+                    return m;
+                },
+                WAITING: this.globalContext.WAITING,
+                process,
+                TextDecoder,
+                URL,
+                Blob,
+                Symbol,
+                Buffer,
+                setImmediate,
+                self: this.globalContext,
+                __TEST_PATH__: __TEST_PATH__,
+                __TEST_SOURCE_PATH__: this._options.source,
+                __TEST_DIST_PATH__: this._options.dist,
+                __MODE__: this._options.compilerOptions.mode,
+                __SNAPSHOT__: external_node_path_default().join(this._options.source, '__snapshot__'),
+                Worker: (0, createFakeWorker_js_namespaceObject.createFakeWorker)(this._options.env, {
+                    outputDirectory: this._options.dist
+                }),
+                ...this._options.env
             };
+            return baseModuleScope;
         }
-        else if (isRelativePath(modulePath)) {
-            const p = node_path_1.default.join(currentDirectory, modulePath);
-            res = {
-                path: p,
-                content: node_fs_1.default.readFileSync(p, 'utf-8'),
-                subPath: getSubPath(modulePath),
+        createModuleScope(requireFn, m, file) {
+            const requirer = requireFn.bind({
+                from: file.path,
+                module: m
+            }, external_node_path_default().dirname(file.path));
+            requirer.webpackTestSuiteRequire = true;
+            return {
+                ...this.baseModuleScope,
+                require: requirer,
+                module: m,
+                exports: m.exports,
+                __dirname: external_node_path_default().dirname(file.path),
+                __filename: file.path,
+                _globalAssign: {
+                    expect: this._options.env.expect
+                }
             };
         }
-        else if (node_path_1.default.isAbsolute(modulePath)) {
-            res = {
+        getFile(modulePath, currentDirectory) {
+            const cacheKey = `${currentDirectory}|${modulePath}`;
+            if (this._options.cachable && cached.has(cacheKey)) return cached.get(cacheKey);
+            let res = null;
+            if (Array.isArray(modulePath)) res = {
+                path: external_node_path_default().join(currentDirectory, '.array-require.js'),
+                content: `module.exports = (${modulePath.map((arg)=>`require(${JSON.stringify(`./${arg}`)})`).join(', ')});`,
+                subPath: ''
+            };
+            else if (modulePath.startsWith('https://test.cases/')) {
+                const relativePath = (0, urlToRelativePath_js_namespaceObject.urlToRelativePath)(modulePath);
+                const absPath = external_node_path_default().join(currentDirectory, relativePath);
+                res = {
+                    path: absPath,
+                    content: external_node_fs_default().readFileSync(absPath, 'utf-8'),
+                    subPath: ''
+                };
+            } else if (isRelativePath(modulePath)) {
+                const p = external_node_path_default().join(currentDirectory, modulePath);
+                res = {
+                    path: p,
+                    content: external_node_fs_default().readFileSync(p, 'utf-8'),
+                    subPath: getSubPath(modulePath)
+                };
+            } else if (external_node_path_default().isAbsolute(modulePath)) res = {
                 path: modulePath,
-                content: node_fs_1.default.readFileSync(modulePath, 'utf-8'),
-                subPath: 'absolute_path',
+                content: external_node_fs_default().readFileSync(modulePath, 'utf-8'),
+                subPath: 'absolute_path'
             };
+            if (this._options.cachable && res) cached.set(cacheKey, res);
+            return res;
         }
-        if (this._options.cachable && res) {
-            cached.set(cacheKey, res);
-        }
-        return res;
-    }
-    preExecute(code, file) { }
-    postExecute(m, file) { }
-    createRunner() {
-        this.requirers.set('cjs', this.createCjsRequirer());
-        this.requirers.set('esm', this.createEsmRequirer());
-        this.requirers.set('miss', this.createMissRequirer());
-        this.requirers.set('json', this.createJsonRequirer());
-        this.requirers.set('entry', (currentDirectory, modulePath, context) => {
-            const file = this.getFile(modulePath, currentDirectory);
-            this.log(`entry: ${modulePath} -> ${file?.path}`);
-            if (!file) {
-                return this.requirers.get('miss')(currentDirectory, modulePath);
-            }
-            if (file.path.endsWith('.json')) {
-                return this.requirers.get('json')(currentDirectory, modulePath, {
+        preExecute(code, file) {}
+        postExecute(m, file) {}
+        createRunner() {
+            this.requirers.set('cjs', this.createCjsRequirer());
+            this.requirers.set('esm', this.createEsmRequirer());
+            this.requirers.set('miss', this.createMissRequirer());
+            this.requirers.set('json', this.createJsonRequirer());
+            this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
+                const file = this.getFile(modulePath, currentDirectory);
+                this.log(`entry: ${modulePath} -> ${file?.path}`);
+                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
+                if (file.path.endsWith('.json')) return this.requirers.get('json')(currentDirectory, modulePath, {
                     ...context,
-                    file,
+                    file
                 });
-            }
-            if (file.path.endsWith('.mjs') ||
-                (0, config_1.enableEsmLibraryPlugin)(this._options.compilerOptions)) {
-                return this.requirers.get('esm')(currentDirectory, modulePath, {
+                if (file.path.endsWith('.mjs') || (0, config_js_namespaceObject.enableEsmLibraryPlugin)(this._options.compilerOptions)) return this.requirers.get('esm')(currentDirectory, modulePath, {
                     ...context,
-                    file,
+                    file
+                });
+                return this.requirers.get('cjs')(currentDirectory, modulePath, {
+                    ...context,
+                    file
                 });
-            }
-            return this.requirers.get('cjs')(currentDirectory, modulePath, {
-                ...context,
-                file,
             });
-        });
-    }
-    createMissRequirer() {
-        return (currentDirectory, modulePath, context = {}) => {
-            this.log(`missing: ${modulePath}`);
-            const modulePathStr = modulePath;
-            const modules = this._options.testConfig.modules;
-            if (modules && modulePathStr in modules) {
-                this.log(`mock module: ${modulePathStr}`);
-                return modules[modulePathStr];
-            }
-            this.log(`native require: ${modulePathStr}`);
-            return require(modulePathStr.startsWith('node:')
-                ? modulePathStr.slice(5)
-                : modulePathStr);
-        };
-    }
-    createJsonRequirer() {
-        return (currentDirectory, modulePath, context = {}) => {
-            if (Array.isArray(modulePath)) {
-                throw new Error('Array module path is not supported in hot cases');
-            }
-            const file = context.file || this.getFile(modulePath, currentDirectory);
-            this.log(`json: ${modulePath} -> ${file?.path}`);
-            if (!file) {
-                return this.requirers.get('miss')(currentDirectory, modulePath);
-            }
-            return JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(this._options.dist, modulePath), 'utf-8'));
-        };
-    }
-    createCjsRequirer() {
-        return (currentDirectory, modulePath, context = {}) => {
-            if (modulePath === '@rspack/test-tools') {
-                return require('@rspack/test-tools');
-            }
-            const file = context.file || this.getFile(modulePath, currentDirectory);
-            this.log(`cjs: ${modulePath} -> ${file?.path}`);
-            if (!file) {
-                return this.requirers.get('miss')(currentDirectory, modulePath);
-            }
-            if (file.path in this.requireCache) {
-                this.log(`cjs cache hit: ${file.path}`);
-                return this.requireCache[file.path].exports;
-            }
-            const m = {
-                exports: {},
-                webpackTestSuiteModule: true,
+        }
+        createMissRequirer() {
+            return (currentDirectory, modulePath, context = {})=>{
+                this.log(`missing: ${modulePath}`);
+                const modulePathStr = modulePath;
+                const modules = this._options.testConfig.modules;
+                if (modules && modulePathStr in modules) {
+                    this.log(`mock module: ${modulePathStr}`);
+                    return modules[modulePathStr];
+                }
+                this.log(`native require: ${modulePathStr}`);
+                return require(modulePathStr.startsWith('node:') ? modulePathStr.slice(5) : modulePathStr);
             };
-            this.requireCache[file.path] = m;
-            if (!this._options.runInNewContext) {
-                file.content = `Object.assign(global, _globalAssign);${file.content}`;
-            }
-            const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
-            if (this._options.testConfig.moduleScope) {
-                this._options.testConfig.moduleScope(currentModuleScope, this._options.stats, this._options.compilerOptions);
-            }
-            if (file.content.includes('__STATS__') && this._options.stats) {
-                currentModuleScope.__STATS__ = this._options.stats();
-            }
-            if (file.content.includes('__STATS_I__')) {
-                const statsIndex = this._options.stats?.()?.__index__;
-                if (typeof statsIndex === 'number') {
-                    currentModuleScope.__STATS_I__ = statsIndex;
+        }
+        createJsonRequirer() {
+            return (currentDirectory, modulePath, context = {})=>{
+                if (Array.isArray(modulePath)) throw new Error('Array module path is not supported in hot cases');
+                const file = context.file || this.getFile(modulePath, currentDirectory);
+                this.log(`json: ${modulePath} -> ${file?.path}`);
+                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
+                return JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(this._options.dist, modulePath), 'utf-8'));
+            };
+        }
+        createCjsRequirer() {
+            return (currentDirectory, modulePath, context = {})=>{
+                if ('@rspack/test-tools' === modulePath) return __webpack_require__("@rspack/test-tools");
+                const file = context.file || this.getFile(modulePath, currentDirectory);
+                this.log(`cjs: ${modulePath} -> ${file?.path}`);
+                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
+                if (file.path in this.requireCache) {
+                    this.log(`cjs cache hit: ${file.path}`);
+                    return this.requireCache[file.path].exports;
                 }
-            }
-            if (file.content.includes('webpack/runtime/startup_chunk_dependencies')) {
-                currentModuleScope.__AFTER_CHUNK_LOADED__ = (next) => {
-                    let done;
-                    const task = new Promise((resolve) => (done = resolve));
-                    currentModuleScope.WAITING.push(task);
-                    return () => {
-                        next();
-                        done();
-                    };
+                const m = {
+                    exports: {},
+                    webpackTestSuiteModule: true
                 };
-                file.content = file.content.replace('var next = __webpack_require__.x', 'var next = __AFTER_CHUNK_LOADED__(__webpack_require__.x)');
-            }
-            const args = Object.keys(currentModuleScope);
-            const argValues = args.map((arg) => currentModuleScope[arg]);
-            const code = `(function(${args.join(', ')}) {
+                this.requireCache[file.path] = m;
+                if (!this._options.runInNewContext) file.content = `Object.assign(global, _globalAssign);${file.content}`;
+                const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
+                if (this._options.testConfig.moduleScope) this._options.testConfig.moduleScope(currentModuleScope, this._options.stats, this._options.compilerOptions);
+                if (file.content.includes('__STATS__') && this._options.stats) currentModuleScope.__STATS__ = this._options.stats();
+                if (file.content.includes('__STATS_I__')) {
+                    const statsIndex = this._options.stats?.()?.__index__;
+                    if ('number' == typeof statsIndex) currentModuleScope.__STATS_I__ = statsIndex;
+                }
+                if (file.content.includes('webpack/runtime/startup_chunk_dependencies')) {
+                    currentModuleScope.__AFTER_CHUNK_LOADED__ = (next)=>{
+                        let done;
+                        const task = new Promise((resolve)=>done = resolve);
+                        currentModuleScope.WAITING.push(task);
+                        return ()=>{
+                            next();
+                            done();
+                        };
+                    };
+                    file.content = file.content.replace('var next = __webpack_require__.x', 'var next = __AFTER_CHUNK_LOADED__(__webpack_require__.x)');
+                }
+                const args = Object.keys(currentModuleScope);
+                const argValues = args.map((arg)=>currentModuleScope[arg]);
+                const code = `(function(${args.join(', ')}) {
 				${file.content}
       })`;
-            this.preExecute(code, file);
-            this.log(`run mode: ${this._options.runInNewContext ? 'new context' : 'this context'}`);
-            try {
-                const fn = this._options.runInNewContext
-                    ? node_vm_1.default.runInNewContext(code, this.globalContext, {
+                this.preExecute(code, file);
+                this.log(`run mode: ${this._options.runInNewContext ? 'new context' : 'this context'}`);
+                try {
+                    const fn = this._options.runInNewContext ? external_node_vm_default().runInNewContext(code, this.globalContext, {
                         filename: file.path,
-                        lineOffset: -1,
-                    })
-                    : node_vm_1.default.runInThisContext(code, {
+                        lineOffset: -1
+                    }) : external_node_vm_default().runInThisContext(code, {
                         filename: file.path,
-                        lineOffset: -1,
+                        lineOffset: -1
                     });
-                fn.call(this._options.testConfig.nonEsmThis
-                    ? this._options.testConfig.nonEsmThis(modulePath)
-                    : m.exports, ...argValues);
-            }
-            catch (e) {
-                this._options.errors?.push(e);
-                throw e;
-            }
-            this.postExecute(m, file);
-            this.log(`end cjs: ${modulePath}`);
-            return m.exports;
-        };
-    }
-    createEsmRequirer() {
-        const esmContext = node_vm_1.default.createContext(this.baseModuleScope, {
-            name: 'context for esm',
-        });
-        const esmCache = new Map();
-        const esmIdentifier = this._options.name;
-        return (currentDirectory, modulePath, context = {}) => {
-            if (!node_vm_1.SourceTextModule) {
-                throw new Error("Running this test requires '--experimental-vm-modules'.\nRun with 'node --experimental-vm-modules node_modules/@rstest/core/bin/rstest'.");
-            }
-            const _require = this.getRequire();
-            const file = context.file || this.getFile(modulePath, currentDirectory);
-            this.log(`esm: ${modulePath} -> ${file?.path}`);
-            if (!file) {
-                return this.requirers.get('miss')(currentDirectory, modulePath);
-            }
-            if (file.content.includes('__STATS__')) {
-                esmContext.__STATS__ = this._options.stats?.();
-            }
-            if (file.content.includes('__STATS_I__')) {
-                const statsIndex = this._options.stats?.()?.__index__;
-                if (typeof statsIndex === 'number') {
-                    esmContext.__STATS_I__ = statsIndex;
+                    fn.call(this._options.testConfig.nonEsmThis ? this._options.testConfig.nonEsmThis(modulePath) : m.exports, ...argValues);
+                } catch (e) {
+                    this._options.errors?.push(e);
+                    throw e;
                 }
-            }
-            let esm = esmCache.get(file.path);
-            if (!esm) {
-                esm = new node_vm_1.SourceTextModule(file.content, {
-                    identifier: `${esmIdentifier}-${file.path}`,
-                    // no attribute
-                    url: `${(0, node_url_1.pathToFileURL)(file.path).href}?${esmIdentifier}`,
-                    context: esmContext,
-                    initializeImportMeta: (meta, _) => {
-                        meta.url = (0, node_url_1.pathToFileURL)(file.path).href;
-                        meta.dirname = node_path_1.default.dirname(file.path);
-                        meta.filename = file.path;
-                    },
-                    importModuleDynamically: async (specifier, module) => {
-                        this.log(`import: ${specifier} from ${file?.path}`);
-                        const result = await _require(node_path_1.default.dirname(file.path), specifier, {
-                            esmMode: type_1.EEsmMode.Evaluated,
-                        });
-                        return await (0, asModule_1.default)(result, module.context);
-                    },
-                });
-                esmCache.set(file.path, esm);
-            }
-            if (context.esmMode === type_1.EEsmMode.Unlinked)
-                return esm;
-            return (async () => {
-                if (esm.status === 'unlinked') {
-                    await esm.link(async (specifier, referencingModule) => {
-                        return await (0, asModule_1.default)(await _require(node_path_1.default.dirname(referencingModule.identifier
-                            ? referencingModule.identifier.slice(esmIdentifier.length + 1)
-                            : (0, node_url_1.fileURLToPath)(referencingModule.url)), specifier, {
-                            esmMode: type_1.EEsmMode.Unlinked,
-                        }), referencingModule.context, true);
-                    });
+                this.postExecute(m, file);
+                this.log(`end cjs: ${modulePath}`);
+                return m.exports;
+            };
+        }
+        createEsmRequirer() {
+            const esmContext = external_node_vm_default().createContext(this.baseModuleScope, {
+                name: 'context for esm'
+            });
+            const esmCache = new Map();
+            const esmIdentifier = this._options.name;
+            return (currentDirectory, modulePath, context = {})=>{
+                if (!external_node_vm_namespaceObject.SourceTextModule) throw new Error("Running this test requires '--experimental-vm-modules'.\nRun with 'node --experimental-vm-modules node_modules/@rstest/core/bin/rstest'.");
+                const _require = this.getRequire();
+                const file = context.file || this.getFile(modulePath, currentDirectory);
+                this.log(`esm: ${modulePath} -> ${file?.path}`);
+                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
+                if (file.content.includes('__STATS__')) esmContext.__STATS__ = this._options.stats?.();
+                if (file.content.includes('__STATS_I__')) {
+                    const statsIndex = this._options.stats?.()?.__index__;
+                    if ('number' == typeof statsIndex) esmContext.__STATS_I__ = statsIndex;
                 }
-                await esm.evaluate();
-                if (context.esmMode === type_1.EEsmMode.Evaluated) {
-                    return esm;
+                let esm = esmCache.get(file.path);
+                if (!esm) {
+                    esm = new external_node_vm_namespaceObject.SourceTextModule(file.content, {
+                        identifier: `${esmIdentifier}-${file.path}`,
+                        url: `${(0, external_node_url_namespaceObject.pathToFileURL)(file.path).href}?${esmIdentifier}`,
+                        context: esmContext,
+                        initializeImportMeta: (meta, _)=>{
+                            meta.url = (0, external_node_url_namespaceObject.pathToFileURL)(file.path).href;
+                            meta.dirname = external_node_path_default().dirname(file.path);
+                            meta.filename = file.path;
+                        },
+                        importModuleDynamically: async (specifier, module)=>{
+                            this.log(`import: ${specifier} from ${file?.path}`);
+                            const result = await _require(external_node_path_default().dirname(file.path), specifier, {
+                                esmMode: external_type_js_namespaceObject.EEsmMode.Evaluated
+                            });
+                            return (0, asModule_js_namespaceObject.asModule)(result, module.context);
+                        }
+                    });
+                    esmCache.set(file.path, esm);
                 }
-                const ns = esm.namespace;
-                this.log(`end esm: ${modulePath}`);
-                return ns.default && ns.default instanceof Promise ? ns.default : ns;
-            })();
-        };
+                if (context.esmMode === external_type_js_namespaceObject.EEsmMode.Unlinked) return esm;
+                return (async ()=>{
+                    if ('unlinked' === esm.status) await esm.link(async (specifier, referencingModule)=>(0, asModule_js_namespaceObject.asModule)(await _require(external_node_path_default().dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : (0, external_node_url_namespaceObject.fileURLToPath)(referencingModule.url)), specifier, {
+                            esmMode: external_type_js_namespaceObject.EEsmMode.Unlinked
+                        }), referencingModule.context, true));
+                    await esm.evaluate();
+                    if (context.esmMode === external_type_js_namespaceObject.EEsmMode.Evaluated) return esm;
+                    const ns = esm.namespace;
+                    this.log(`end esm: ${modulePath}`);
+                    return ns.default && ns.default instanceof Promise ? ns.default : ns;
+                })();
+            };
+        }
     }
-}
-exports.NodeRunner = NodeRunner;
+})();
+exports.NodeRunner = __webpack_exports__.NodeRunner;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NodeRunner"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});