@rstest/core 0.5.1 → 0.5.3

package/dist/0~876.js

@@ -1,771 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-import { stripVTControlCharacters } from "node:util";
-export const __webpack_id__ = "876";
-export const __webpack_ids__ = [
-    "876"
-];
-export const __webpack_modules__ = {
-    "./src/core/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            createRstest: ()=>createRstest
-        });
-        var external_node_fs_ = __webpack_require__("node:fs");
-        var manager = __webpack_require__("../../node_modules/.pnpm/@vitest+snapshot@3.2.4/node_modules/@vitest/snapshot/dist/manager.js");
-        var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
-        var dist = __webpack_require__("../../node_modules/.pnpm/std-env@3.9.0/node_modules/std-env/dist/index.mjs");
-        var src_config = __webpack_require__("./src/config.ts");
-        var stack_trace_parser_esm = __webpack_require__("../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js");
-        var utils = __webpack_require__("./src/utils/index.ts");
-        const DEFAULT_RENDER_INTERVAL_MS = 1000;
-        const ESC = '\x1B[';
-        const CLEAR_LINE = `${ESC}K`;
-        const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
-        const SYNC_START = `${ESC}?2026h`;
-        const SYNC_END = `${ESC}?2026l`;
-        class WindowRenderer {
-            options;
-            streams;
-            buffer = [];
-            renderInterval = void 0;
-            renderScheduled = false;
-            windowHeight = 0;
-            finished = false;
-            cleanups = [];
-            constructor(options){
-                this.options = {
-                    interval: DEFAULT_RENDER_INTERVAL_MS,
-                    ...options
-                };
-                this.streams = {
-                    output: options.logger.outputStream.write.bind(options.logger.outputStream),
-                    error: options.logger.errorStream.write.bind(options.logger.errorStream)
-                };
-                this.cleanups.push(this.interceptStream(process.stdout, 'output'), this.interceptStream(process.stderr, 'error'));
-                this.start();
-            }
-            start() {
-                this.finished = false;
-                this.renderInterval = setInterval(()=>this.schedule(), this.options.interval).unref();
-            }
-            stop() {
-                this.cleanups.splice(0).map((fn)=>fn());
-                clearInterval(this.renderInterval);
-            }
-            finish() {
-                this.finished = true;
-                this.flushBuffer();
-                clearInterval(this.renderInterval);
-            }
-            schedule() {
-                if (!this.renderScheduled) {
-                    this.renderScheduled = true;
-                    this.flushBuffer();
-                    setTimeout(()=>{
-                        this.renderScheduled = false;
-                    }, 100).unref();
-                }
-            }
-            flushBuffer() {
-                if (0 === this.buffer.length) return this.render();
-                let current;
-                for (const next of this.buffer.splice(0)){
-                    if (!current) {
-                        current = next;
-                        continue;
-                    }
-                    if (current.type !== next.type) {
-                        this.render(current.message, current.type);
-                        current = next;
-                        continue;
-                    }
-                    current.message += next.message;
-                }
-                if (current) this.render(current?.message, current?.type);
-            }
-            render(message, type = 'output') {
-                if (this.finished) {
-                    this.clearWindow();
-                    return this.write(message || '', type);
-                }
-                const windowContent = this.options.getWindow();
-                const rowCount = getRenderedRowCount(windowContent, this.options.logger.getColumns());
-                let padding = this.windowHeight - rowCount;
-                if (padding > 0 && message) padding -= getRenderedRowCount([
-                    message
-                ], this.options.logger.getColumns());
-                this.write(SYNC_START);
-                this.clearWindow();
-                if (message) this.write(message, type);
-                if (padding > 0) this.write('\n'.repeat(padding));
-                this.write(windowContent.join('\n'));
-                this.write(SYNC_END);
-                this.windowHeight = rowCount + Math.max(0, padding);
-            }
-            clearWindow() {
-                if (0 === this.windowHeight) return;
-                this.write(CLEAR_LINE);
-                for(let i = 1; i < this.windowHeight; i++)this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
-                this.windowHeight = 0;
-            }
-            interceptStream(stream, type) {
-                const original = stream.write.bind(stream);
-                stream.write = (chunk, _, callback)=>{
-                    if (chunk) if (this.finished) this.write(chunk.toString(), type);
-                    else this.buffer.push({
-                        type,
-                        message: chunk.toString()
-                    });
-                    callback?.();
-                };
-                return function restore() {
-                    stream.write = original;
-                };
-            }
-            write(message, type = 'output') {
-                this.streams[type](message);
-            }
-        }
-        function getRenderedRowCount(rows, columns) {
-            let count = 0;
-            for (const row of rows){
-                const text = stripVTControlCharacters(row);
-                count += Math.max(1, Math.ceil(text.length / columns));
-            }
-            return count;
-        }
-        class StatusRenderer {
-            rootPath;
-            renderer;
-            runningModules = new Set();
-            constructor(rootPath){
-                this.rootPath = rootPath;
-                this.renderer = new WindowRenderer({
-                    getWindow: ()=>this.getContent(),
-                    logger: {
-                        outputStream: process.stdout,
-                        errorStream: process.stderr,
-                        getColumns: ()=>'columns' in process.stdout ? process.stdout.columns : 80
-                    }
-                });
-            }
-            getContent() {
-                const summary = [];
-                for (const module of this.runningModules){
-                    const relativePath = (0, pathe_M_eThtNZ.b)(this.rootPath, module);
-                    summary.push(`${utils.yW.bgYellow(utils.yW.bold(' RUNS '))} ${(0, utils.EQ)(relativePath)}`);
-                }
-                summary.push('');
-                return summary;
-            }
-            addRunningModule(testPath) {
-                this.runningModules.add(testPath);
-                this.renderer?.schedule();
-            }
-            removeRunningModule(testPath) {
-                this.runningModules.delete(testPath);
-                this.renderer?.schedule();
-            }
-            clear() {
-                this.runningModules.clear();
-                this.renderer?.finish();
-            }
-        }
-        var pathe_dist = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs");
-        const getSummaryStatusString = (tasks, name = 'tests', showTotal = true)=>{
-            if (0 === tasks.length) return utils.yW.dim(`no ${name}`);
-            const passed = tasks.filter((result)=>'pass' === result.status);
-            const failed = tasks.filter((result)=>'fail' === result.status);
-            const skipped = tasks.filter((result)=>'skip' === result.status);
-            const todo = tasks.filter((result)=>'todo' === result.status);
-            const status = [
-                failed.length ? utils.yW.bold(utils.yW.red(`${failed.length} failed`)) : null,
-                passed.length ? utils.yW.bold(utils.yW.green(`${passed.length} passed`)) : null,
-                skipped.length ? utils.yW.yellow(`${skipped.length} skipped`) : null,
-                todo.length ? utils.yW.gray(`${todo.length} todo`) : null
-            ].filter(Boolean);
-            return status.join(utils.yW.dim(' | ')) + (showTotal && status.length > 1 ? utils.yW.gray(` (${tasks.length})`) : '');
-        };
-        const printSnapshotSummaryLog = (snapshots, rootDir)=>{
-            const summary = [];
-            if (snapshots.added) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.added} written`)));
-            if (snapshots.unmatched) summary.push(utils.yW.bold(utils.yW.red(`${snapshots.unmatched} failed`)));
-            if (snapshots.updated) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.updated} updated `)));
-            if (snapshots.filesRemoved) if (snapshots.didUpdate) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.filesRemoved} files removed `)));
-            else summary.push(utils.yW.bold(utils.yW.yellow(`${snapshots.filesRemoved} files obsolete `)));
-            const POINTER = '➜';
-            if (snapshots.filesRemovedList?.length) {
-                const [head, ...tail] = snapshots.filesRemovedList;
-                summary.push(`${utils.yW.gray(POINTER)} ${(0, utils.XJ)(rootDir, head)}`);
-                for (const key of tail)summary.push(`  ${(0, utils.XJ)(rootDir, key)}`);
-            }
-            if (snapshots.unchecked) {
-                if (snapshots.didUpdate) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.unchecked} removed`)));
-                else summary.push(utils.yW.bold(utils.yW.yellow(`${snapshots.unchecked} obsolete`)));
-                for (const uncheckedFile of snapshots.uncheckedKeysByFile){
-                    summary.push(`${utils.yW.gray(POINTER)} ${(0, utils.XJ)(rootDir, uncheckedFile.filePath)}`);
-                    for (const key of uncheckedFile.keys)summary.push(`  ${key}`);
-                }
-            }
-            for (const [index, snapshot] of summary.entries()){
-                const title = 0 === index ? 'Snapshots' : '';
-                utils.vF.log(`${utils.yW.gray(title.padStart(12))} ${snapshot}`);
-            }
-        };
-        const printSummaryLog = ({ results, testResults, snapshotSummary, duration, rootPath })=>{
-            utils.vF.log('');
-            printSnapshotSummaryLog(snapshotSummary, rootPath);
-            utils.vF.log(`${utils.yW.gray('Test Files'.padStart(11))} ${getSummaryStatusString(results)}`);
-            utils.vF.log(`${utils.yW.gray('Tests'.padStart(11))} ${getSummaryStatusString(testResults)}`);
-            utils.vF.log(`${utils.yW.gray('Duration'.padStart(11))} ${(0, utils.kV)(duration.totalTime)} ${utils.yW.gray(`(build ${(0, utils.kV)(duration.buildTime)}, tests ${(0, utils.kV)(duration.testTime)})`)}`);
-            utils.vF.log('');
-        };
-        const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap, filterRerunTestPaths })=>{
-            const failedTests = [
-                ...results.filter((i)=>'fail' === i.status && i.errors?.length && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true)),
-                ...testResults.filter((i)=>'fail' === i.status && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true))
-            ];
-            if (0 === failedTests.length) return;
-            utils.vF.log('');
-            utils.vF.log(utils.yW.bold('Summary of all failing tests:'));
-            utils.vF.log('');
-            for (const test of failedTests){
-                const relativePath = pathe_dist.Ay.relative(rootPath, test.testPath);
-                const nameStr = (0, utils.fN)(test);
-                utils.vF.log(`${utils.yW.bgRed(' FAIL ')} ${(0, utils.EQ)(relativePath)} ${nameStr.length ? `${utils.yW.dim(utils.vO)} ${nameStr}` : ''}`);
-                if (test.errors) {
-                    const { printError } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
-                    for (const error of test.errors)await printError(error, getSourcemap, rootPath);
-                }
-            }
-        };
-        const statusStr = {
-            fail: '✗',
-            pass: '✓',
-            todo: '-',
-            skip: '-'
-        };
-        const statusColorfulStr = {
-            fail: utils.yW.red(statusStr.fail),
-            pass: utils.yW.green(statusStr.pass),
-            todo: utils.yW.gray(statusStr.todo),
-            skip: utils.yW.gray(statusStr.skip)
-        };
-        const logCase = (result, slowTestThreshold)=>{
-            const isSlowCase = (result.duration || 0) > slowTestThreshold;
-            const icon = isSlowCase && 'pass' === result.status ? utils.yW.yellow(statusStr[result.status]) : statusColorfulStr[result.status];
-            const nameStr = (0, utils.fN)(result);
-            const duration = void 0 !== result.duration ? ` (${(0, utils.kV)(result.duration)})` : '';
-            const retry = result.retryCount ? utils.yW.yellow(` (retry x${result.retryCount})`) : '';
-            utils.vF.log(`  ${icon} ${nameStr}${utils.yW.gray(duration)}${retry}`);
-            if (result.errors) for (const error of result.errors)console.error(utils.yW.red(`    ${error.message}`));
-        };
-        const logFileTitle = (test, relativePath, slowTestThreshold, alwaysShowTime = false)=>{
-            let title = ` ${utils.yW.bold(statusColorfulStr[test.status])} ${(0, utils.EQ)(relativePath)}`;
-            const formatDuration = (duration)=>utils.yW[duration > slowTestThreshold ? 'yellow' : 'green']((0, utils.kV)(duration));
-            title += ` ${utils.yW.gray(`(${test.results.length})`)}`;
-            const isTooSlow = test.duration && test.duration > slowTestThreshold;
-            if (alwaysShowTime || isTooSlow) title += ` ${formatDuration(test.duration)}`;
-            utils.vF.log(title);
-        };
-        class DefaultReporter {
-            rootPath;
-            config;
-            options = {};
-            statusRenderer;
-            constructor({ rootPath, options, config }){
-                this.rootPath = rootPath;
-                this.config = config;
-                this.options = options;
-                if (!dist.JO) this.statusRenderer = new StatusRenderer(rootPath);
-            }
-            onTestFileStart(test) {
-                this.statusRenderer?.addRunningModule(test.testPath);
-            }
-            onTestFileResult(test) {
-                this.statusRenderer?.removeRunningModule(test.testPath);
-                const relativePath = (0, pathe_M_eThtNZ.b)(this.rootPath, test.testPath);
-                const { slowTestThreshold } = this.config;
-                logFileTitle(test, relativePath, slowTestThreshold);
-                const isTooSlow = test.duration && test.duration > slowTestThreshold;
-                const hasRetryCase = test.results.some((result)=>(result.retryCount || 0) > 0);
-                if ('fail' !== test.status && !isTooSlow && !hasRetryCase) return;
-                const showAllCases = isTooSlow && !test.results.some((result)=>(result.duration || 0) > slowTestThreshold);
-                for (const result of test.results){
-                    const isSlowCase = (result.duration || 0) > slowTestThreshold;
-                    const retried = (result.retryCount || 0) > 0;
-                    if (showAllCases || 'fail' === result.status || isSlowCase || retried) logCase(result, slowTestThreshold);
-                }
-            }
-            onTestCaseResult(_result) {}
-            onUserConsoleLog(log) {
-                const shouldLog = this.config.onConsoleLog?.(log.content) ?? true;
-                if (!shouldLog) return;
-                const titles = [
-                    log.name
-                ];
-                const testPath = (0, pathe_M_eThtNZ.b)(this.rootPath, log.testPath);
-                if (log.trace) {
-                    const [frame] = (0, stack_trace_parser_esm.q)(log.trace);
-                    const filePath = (0, pathe_M_eThtNZ.b)(this.rootPath, frame.file || '');
-                    if (filePath !== testPath) titles.push((0, utils.EQ)(testPath));
-                    titles.push((0, utils.EQ)(filePath) + utils.yW.gray(`:${frame.lineNumber}:${frame.column}`));
-                } else titles.push((0, utils.EQ)(testPath));
-                utils.vF.log(titles.join(utils.yW.gray(' | ')));
-                utils.vF.log(log.content);
-                utils.vF.log('');
-            }
-            async onExit() {
-                this.statusRenderer?.clear();
-            }
-            async onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths }) {
-                this.statusRenderer?.clear();
-                if (false === this.options.summary) return;
-                await printSummaryErrorLogs({
-                    testResults,
-                    results,
-                    rootPath: this.rootPath,
-                    getSourcemap,
-                    filterRerunTestPaths
-                });
-                printSummaryLog({
-                    results,
-                    testResults,
-                    duration,
-                    rootPath: this.rootPath,
-                    snapshotSummary
-                });
-            }
-        }
-        class GithubActionsReporter {
-            onWritePath;
-            rootPath;
-            constructor({ options, rootPath }){
-                this.onWritePath = options.onWritePath;
-                this.rootPath = rootPath;
-            }
-            log(message) {
-                console.log(`${message}\n`);
-            }
-            async onTestRunEnd({ results, testResults, getSourcemap }) {
-                const failedTests = [
-                    ...results.filter((i)=>'fail' === i.status && i.errors?.length),
-                    ...testResults.filter((i)=>'fail' === i.status)
-                ];
-                if (0 === failedTests.length) return;
-                const { parseErrorStacktrace } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
-                const logs = [];
-                for (const test of failedTests){
-                    const { testPath } = test;
-                    const nameStr = (0, utils.fN)(test);
-                    const shortPath = (0, pathe_M_eThtNZ.b)(this.rootPath, testPath);
-                    const title = `${shortPath} ${utils.vO} ${nameStr}`;
-                    for (const error of test.errors || []){
-                        let file = testPath;
-                        let line = 1;
-                        let column = 1;
-                        const message = `${error.message}${error.diff ? `\n${error.diff}` : ''}`;
-                        const type = 'error';
-                        if (error.stack) {
-                            const stackFrames = await parseErrorStacktrace({
-                                stack: error.stack,
-                                fullStack: error.fullStack,
-                                getSourcemap
-                            });
-                            if (stackFrames[0]) {
-                                file = stackFrames[0].file || test.testPath;
-                                line = stackFrames[0].lineNumber || 1;
-                                column = stackFrames[0].column || 1;
-                            }
-                        }
-                        logs.push(`::${type} file=${this.onWritePath?.(file) || file},line=${line},col=${column},title=${escapeData(title)}::${escapeData(message)}`);
-                    }
-                }
-                this.log('::group::error for github actions');
-                for (const log of logs)this.log(log);
-                this.log('::endgroup::');
-            }
-        }
-        function escapeData(s) {
-            return s.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A').replace(/:/g, '%3A').replace(/,/g, '%2C');
-        }
-        var promises_ = __webpack_require__("node:fs/promises");
-        var strip_ansi = __webpack_require__("../../node_modules/.pnpm/strip-ansi@7.1.2/node_modules/strip-ansi/index.js");
-        var utils_error = __webpack_require__("./src/utils/error.ts");
-        class JUnitReporter {
-            rootPath;
-            outputPath;
-            constructor({ rootPath, options: { outputPath } = {} }){
-                this.rootPath = rootPath;
-                this.outputPath = outputPath;
-            }
-            sanitizeXml(text) {
-                let result = '';
-                for (const ch of (0, strip_ansi.A)(text)){
-                    const cp = ch.codePointAt(0);
-                    const valid = 0x09 === cp || 0x0a === cp || 0x0d === cp || cp >= 0x20 && cp <= 0xd7ff || cp >= 0xe000 && cp <= 0xfffd || cp >= 0x10000 && cp <= 0x10ffff;
-                    if (valid) result += ch;
-                }
-                return result;
-            }
-            escapeXml(text) {
-                const sanitized = this.sanitizeXml(text);
-                return sanitized.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
-            }
-            async createJUnitTestCase(test, getSourcemap) {
-                const testCase = {
-                    name: (0, utils.fN)(test),
-                    classname: (0, pathe_M_eThtNZ.b)(this.rootPath, test.testPath),
-                    time: (test.duration || 0) / 1000,
-                    status: test.status
-                };
-                if (test.errors && test.errors.length > 0) testCase.errors = await Promise.all(test.errors.map(async (error)=>{
-                    let details = `${error.message}${error.diff ? `\n${error.diff}` : ''}`;
-                    const stackFrames = error.stack ? await (0, utils_error.parseErrorStacktrace)({
-                        stack: error.stack,
-                        fullStack: error.fullStack,
-                        getSourcemap
-                    }) : [];
-                    if (stackFrames[0]) details += `\n${(0, utils_error.C)(stackFrames[0], this.rootPath)}`;
-                    return {
-                        message: this.escapeXml(error.message),
-                        type: error.name || 'Error',
-                        details: this.escapeXml(details)
-                    };
-                }));
-                return testCase;
-            }
-            async createJUnitTestSuite(fileResult, getSourcemap) {
-                const testCases = await Promise.all(fileResult.results.map(async (test)=>this.createJUnitTestCase(test, getSourcemap)));
-                const failures = testCases.filter((test)=>'fail' === test.status).length;
-                const errors = 0;
-                const skipped = testCases.filter((test)=>'skip' === test.status || 'todo' === test.status).length;
-                const totalTime = testCases.reduce((sum, test)=>sum + test.time, 0);
-                return {
-                    name: (0, pathe_M_eThtNZ.b)(this.rootPath, fileResult.testPath),
-                    tests: testCases.length,
-                    failures,
-                    errors,
-                    skipped,
-                    time: totalTime,
-                    timestamp: new Date().toISOString(),
-                    testcases: testCases
-                };
-            }
-            generateJUnitXml(report) {
-                const xmlDeclaration = '<?xml version="1.0" encoding="UTF-8"?>';
-                const testsuitesXml = `
-<testsuites name="${this.escapeXml(report.testsuites.name)}" tests="${report.testsuites.tests}" failures="${report.testsuites.failures}" errors="${report.testsuites.errors}" skipped="${report.testsuites.skipped}" time="${report.testsuites.time}" timestamp="${this.escapeXml(report.testsuites.timestamp)}">`;
-                const testsuiteXmls = report.testsuites.testsuite.map((suite)=>{
-                    const testsuiteStart = `
-  <testsuite name="${this.escapeXml(suite.name)}" tests="${suite.tests}" failures="${suite.failures}" errors="${suite.errors}" skipped="${suite.skipped}" time="${suite.time}" timestamp="${this.escapeXml(suite.timestamp)}">`;
-                    const testcaseXmls = suite.testcases.map((testcase)=>{
-                        let testcaseXml = `
-    <testcase name="${this.escapeXml(testcase.name)}" classname="${this.escapeXml(testcase.classname)}" time="${testcase.time}">`;
-                        if ('skip' === testcase.status || 'todo' === testcase.status) testcaseXml += `
-      <skipped/>`;
-                        else if ('fail' === testcase.status && testcase.errors) testcase.errors.forEach((error)=>{
-                            testcaseXml += `
-      <failure message="${error.message}" type="${error.type}">${error.details || ''}</failure>`;
-                        });
-                        testcaseXml += `
-    </testcase>`;
-                        return testcaseXml;
-                    }).join('');
-                    const testsuiteEnd = `
-  </testsuite>`;
-                    return testsuiteStart + testcaseXmls + testsuiteEnd;
-                }).join('');
-                const testsuitesEnd = `
-</testsuites>`;
-                return xmlDeclaration + testsuitesXml + testsuiteXmls + testsuitesEnd;
-            }
-            async onTestRunEnd({ results, testResults, duration, getSourcemap }) {
-                const testSuites = await Promise.all(results.map(async (fileResult)=>this.createJUnitTestSuite(fileResult, getSourcemap)));
-                const totalTests = testResults.length;
-                const totalFailures = testResults.filter((test)=>'fail' === test.status).length;
-                const totalErrors = 0;
-                const totalSkipped = testResults.filter((test)=>'skip' === test.status || 'todo' === test.status).length;
-                const totalTime = duration.testTime / 1000;
-                const report = {
-                    testsuites: {
-                        name: 'rstest tests',
-                        tests: totalTests,
-                        failures: totalFailures,
-                        errors: totalErrors,
-                        skipped: totalSkipped,
-                        time: totalTime,
-                        timestamp: new Date().toISOString(),
-                        testsuite: testSuites
-                    }
-                };
-                const xmlContent = this.generateJUnitXml(report);
-                if (this.outputPath) try {
-                    await (0, promises_.writeFile)(this.outputPath, xmlContent, 'utf-8');
-                    console.log(`JUnit XML report written to: ${this.outputPath}`);
-                } catch (error) {
-                    console.error(`Failed to write JUnit XML report to ${this.outputPath}:`, error);
-                    console.log('JUnit XML Report:');
-                    console.log(xmlContent);
-                }
-                else console.log(xmlContent);
-            }
-        }
-        class VerboseReporter extends DefaultReporter {
-            onTestFileResult(test) {
-                this.statusRenderer?.removeRunningModule(test.testPath);
-                const relativePath = (0, pathe_M_eThtNZ.b)(this.rootPath, test.testPath);
-                const { slowTestThreshold } = this.config;
-                logFileTitle(test, relativePath, slowTestThreshold, true);
-                for (const result of test.results)logCase(result, slowTestThreshold);
-            }
-        }
-        function formatEnvironmentName(name) {
-            return name.replace(/[^a-zA-Z0-9\-_$]/g, '_');
-        }
-        class Rstest {
-            cwd;
-            command;
-            fileFilters;
-            configFilePath;
-            reporters;
-            snapshotManager;
-            version;
-            rootPath;
-            originalConfig;
-            normalizedConfig;
-            idMap = new Map();
-            reporterResults = {
-                results: [],
-                testResults: []
-            };
-            projects = [];
-            constructor({ cwd = process.cwd(), command, fileFilters, configFilePath, projects }, userConfig){
-                this.cwd = cwd;
-                this.command = command;
-                this.fileFilters = fileFilters;
-                this.configFilePath = configFilePath;
-                const rootPath = userConfig.root ? (0, utils.FI)(cwd, userConfig.root) : cwd;
-                const rstestConfig = (0, src_config.wX)({
-                    ...userConfig,
-                    root: rootPath
-                });
-                const reporters = 'list' !== command ? createReporters(rstestConfig.reporters, {
-                    rootPath,
-                    config: rstestConfig
-                }) : [];
-                const snapshotManager = new manager.CW({
-                    updateSnapshot: rstestConfig.update ? 'all' : dist.JO ? 'none' : 'new'
-                });
-                this.reporters = reporters;
-                this.snapshotManager = snapshotManager;
-                this.version = "0.5.1";
-                this.rootPath = rootPath;
-                this.originalConfig = userConfig;
-                this.normalizedConfig = rstestConfig;
-                this.projects = projects.length ? projects.map((project)=>{
-                    const config = (0, src_config.wX)(project.config);
-                    config.isolate = rstestConfig.isolate;
-                    config.source ??= {};
-                    config.coverage = rstestConfig.coverage;
-                    if (!config.source.tsconfigPath) {
-                        const tsconfigPath = (0, pathe_M_eThtNZ.j)(config.root, utils.WB);
-                        if ((0, external_node_fs_.existsSync)(tsconfigPath)) config.source.tsconfigPath = tsconfigPath;
-                    }
-                    return {
-                        configFilePath: project.configFilePath,
-                        rootPath: config.root,
-                        name: config.name,
-                        environmentName: formatEnvironmentName(config.name),
-                        normalizedConfig: config
-                    };
-                }) : [
-                    {
-                        configFilePath,
-                        rootPath,
-                        name: rstestConfig.name,
-                        environmentName: formatEnvironmentName(rstestConfig.name),
-                        normalizedConfig: rstestConfig
-                    }
-                ];
-            }
-            updateReporterResultState(results, testResults, deletedEntries = []) {
-                results.forEach((item)=>{
-                    const existingIndex = this.reporterResults.results.findIndex((r)=>r.testPath === item.testPath);
-                    if (-1 !== existingIndex) this.reporterResults.results[existingIndex] = item;
-                    else this.reporterResults.results.push(item);
-                });
-                const testPathsToUpdate = new Set(testResults.map((r)=>r.testPath));
-                this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!testPathsToUpdate.has(r.testPath));
-                this.reporterResults.testResults.push(...testResults);
-                if (deletedEntries.length > 0) {
-                    const deletedPathsSet = new Set(deletedEntries);
-                    this.reporterResults.results = this.reporterResults.results.filter((r)=>!deletedPathsSet.has(r.testPath));
-                    this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!deletedPathsSet.has(r.testPath));
-                }
-            }
-        }
-        const reportersMap = {
-            default: DefaultReporter,
-            verbose: VerboseReporter,
-            'github-actions': GithubActionsReporter,
-            junit: JUnitReporter
-        };
-        function createReporters(reporters, initOptions = {}) {
-            const result = (0, utils.bg)(reporters).map((reporter)=>{
-                if ('string' == typeof reporter || Array.isArray(reporter)) {
-                    const [name, options = {}] = 'string' == typeof reporter ? [
-                        reporter,
-                        {}
-                    ] : reporter;
-                    if (name in reportersMap) {
-                        const Reporter = reportersMap[name];
-                        return new Reporter({
-                            ...initOptions,
-                            options
-                        });
-                    }
-                    throw new Error(`Reporter ${reporter} not found. Please install it or use a built-in reporter.`);
-                }
-                return reporter;
-            });
-            return result;
-        }
-        function createRstest({ config, projects, configFilePath }, command, fileFilters) {
-            const context = new Rstest({
-                cwd: process.cwd(),
-                command,
-                fileFilters,
-                configFilePath,
-                projects
-            }, config);
-            const runTests = async ()=>{
-                const { runTests } = await Promise.all([
-                    __webpack_require__.e("816"),
-                    __webpack_require__.e("33")
-                ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/runTests.ts"));
-                await runTests(context);
-            };
-            const listTests = async (options)=>{
-                const { listTests } = await Promise.all([
-                    __webpack_require__.e("816"),
-                    __webpack_require__.e("971")
-                ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/listTests.ts"));
-                await listTests(context, options);
-            };
-            return {
-                context,
-                runTests,
-                listTests
-            };
-        }
-    },
-    "./src/utils/error.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            C: ()=>formatStack,
-            parseErrorStacktrace: ()=>parseErrorStacktrace,
-            printError: ()=>printError
-        });
-        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
-        var _jridgewell_trace_mapping__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs");
-        var stacktrace_parser__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js");
-        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
-        async function printError(error, getSourcemap, rootPath) {
-            const errorName = error.name || 'Unknown Error';
-            if (error.message.includes('Vitest failed to access its internal state')) {
-                const tips = [
-                    'Error: not support import `vitest` in Rstest test environment.\n',
-                    'Solution:',
-                    `  - Update your code to use imports from "${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.yellow('@rstest/core')}" instead of "${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.yellow('vitest')}".`,
-                    '  - Enable `globals` configuration and use global API.'
-                ];
-                _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.red(tips.join('\n'))}\n`);
-                return;
-            }
-            if (error.message.includes('is not defined')) {
-                const [, varName] = error.message.match(/(.*) is not defined/) || [];
-                if (varName) {
-                    if (_utils__WEBPACK_IMPORTED_MODULE_3__.TE.includes(varName)) error.message = error.message.replace(`${varName} is not defined`, `${varName} is not defined. Did you forget to enable "globals" configuration?`);
-                    else if ([
-                        'jest',
-                        'vitest'
-                    ].includes(varName)) error.message = error.message.replace(`${varName} is not defined`, `${varName} is not defined. Did you mean rstest?`);
-                }
-            }
-            _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.red(_utils__WEBPACK_IMPORTED_MODULE_3__.yW.bold(errorName))}${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.red(`: ${error.message}`)}\n`);
-            if (error.diff) {
-                _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(error.diff);
-                _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log();
-            }
-            if (error.stack) {
-                const stackFrames = await parseErrorStacktrace({
-                    stack: error.stack,
-                    fullStack: error.fullStack,
-                    getSourcemap
-                });
-                if (!stackFrames.length && error.stack.length) _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(_utils__WEBPACK_IMPORTED_MODULE_3__.yW.gray("No error stack found, set 'DEBUG=rstest' to show fullStack."));
-                if (stackFrames[0]) await printCodeFrame(stackFrames[0]);
-                printStack(stackFrames, rootPath);
-            }
-        }
-        async function printCodeFrame(frame) {
-            const filePath = frame.file?.startsWith('file') ? new URL(frame.file) : frame.file;
-            if (!filePath) return;
-            const source = node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].existsSync(filePath) ? node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].readFileSync(filePath, 'utf-8') : void 0;
-            if (!source) return;
-            const { codeFrameColumns } = await __webpack_require__.e("171").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/@babel+code-frame@7.27.1/node_modules/@babel/code-frame/lib/index.js"));
-            const result = codeFrameColumns(source, {
-                start: {
-                    line: frame.lineNumber,
-                    column: frame.column
-                }
-            }, {
-                highlightCode: true,
-                linesBelow: 2
-            });
-            _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(result);
-            _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log('');
-        }
-        function formatStack(frame, rootPath) {
-            return '<unknown>' !== frame.methodName ? `at ${frame.methodName} (${(0, _utils__WEBPACK_IMPORTED_MODULE_3__.XJ)(rootPath, frame.file)}:${frame.lineNumber}:${frame.column})` : `at ${(0, _utils__WEBPACK_IMPORTED_MODULE_3__.XJ)(rootPath, frame.file)}:${frame.lineNumber}:${frame.column}`;
-        }
-        function printStack(stackFrames, rootPath) {
-            for (const frame of stackFrames)_utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(_utils__WEBPACK_IMPORTED_MODULE_3__.yW.gray(`        ${formatStack(frame, rootPath)}`));
-            stackFrames.length && _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log();
-        }
-        const stackIgnores = [
-            /\/@rstest\/core/,
-            /rstest\/packages\/core\/dist/,
-            /node_modules\/tinypool/,
-            /node_modules\/chai/,
-            /node_modules\/@vitest\/expect/,
-            /node_modules\/@vitest\/snapshot/,
-            /node:\w+/,
-            /webpack\/runtime/,
-            /webpack\\runtime/,
-            '<anonymous>'
-        ];
-        async function parseErrorStacktrace({ stack, getSourcemap, fullStack = (0, _utils__WEBPACK_IMPORTED_MODULE_3__._o)() }) {
-            const stackFrames = await Promise.all((0, stacktrace_parser__WEBPACK_IMPORTED_MODULE_2__.q)(stack).filter((frame)=>fullStack ? true : frame.file && !stackIgnores.some((entry)=>frame.file?.match(entry))).map(async (frame)=>{
-                const sourcemap = getSourcemap(frame.file);
-                if (sourcemap) {
-                    const traceMap = new _jridgewell_trace_mapping__WEBPACK_IMPORTED_MODULE_1__.YX(sourcemap);
-                    const { line, column, source, name } = (0, _jridgewell_trace_mapping__WEBPACK_IMPORTED_MODULE_1__.sP)(traceMap, {
-                        line: frame.lineNumber,
-                        column: frame.column
-                    });
-                    if (!source) return null;
-                    return {
-                        ...frame,
-                        file: source,
-                        lineNumber: line,
-                        name,
-                        column
-                    };
-                }
-                return frame;
-            })).then((frames)=>frames.filter((frame)=>null !== frame));
-            return stackFrames;
-        }
-    }
-};