@rstest/core 0.4.1 → 0.5.0

package/dist/index.js

@@ -8,7 +8,6 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__ from "node:module";
 import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_node_tty_c64aab7e__ from "node:tty";
-import * as __WEBPACK_EXTERNAL_MODULE_pathe__ from "pathe";
 import * as __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__ from "node:process";
 import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
 import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
@@ -1976,7 +1975,7 @@ ${section.body}` : section.body).join("\n\n"));
         }
         const cac = (name = "")=>new CAC(name);
         const dist = cac;
-        var external_pathe_ = __webpack_require__("pathe");
+        var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
         var helper = __webpack_require__("./src/utils/helper.ts");
         var logger = __webpack_require__("./src/utils/logger.ts");
         var prepare = __webpack_require__("./src/cli/prepare.ts");
@@ -1991,14 +1990,14 @@ ${section.body}` : section.body).join("\n\n"));
                 const { initCli } = await __webpack_require__.e("223").then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
                 const { config, configFilePath, projects } = await initCli(options);
                 const { createRstest } = await Promise.all([
-                    __webpack_require__.e("120"),
-                    __webpack_require__.e("669")
+                    __webpack_require__.e("908"),
+                    __webpack_require__.e("876")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
                 rstest = createRstest({
                     config,
                     configFilePath,
                     projects
-                }, command, filters.map(external_pathe_.normalize));
+                }, command, filters.map(pathe_M_eThtNZ.n));
                 if ('watch' === command && configFilePath) {
                     const { watchFilesForRestart } = await __webpack_require__.e("967").then(__webpack_require__.bind(__webpack_require__, "./src/core/restart.ts"));
                     watchFilesForRestart({
@@ -2018,7 +2017,7 @@ ${section.body}` : section.body).join("\n\n"));
         function setupCommands() {
             const cli = dist('rstest');
             cli.help();
-            cli.version("0.4.1");
+            cli.version("0.5.0");
             applyCommonOptions(cli);
             cli.command('[...filters]', 'run tests').option('-w, --watch', 'Run tests in watch mode').action(async (filters, options)=>{
                 (0, prepare.N)();
@@ -2054,14 +2053,14 @@ ${section.body}` : section.body).join("\n\n"));
                     const { initCli } = await __webpack_require__.e("223").then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
                     const { config, configFilePath, projects } = await initCli(options);
                     const { createRstest } = await Promise.all([
-                        __webpack_require__.e("120"),
-                        __webpack_require__.e("669")
+                        __webpack_require__.e("908"),
+                        __webpack_require__.e("876")
                     ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
                     const rstest = createRstest({
                         config,
                         configFilePath,
                         projects
-                    }, 'list', filters.map(external_pathe_.normalize));
+                    }, 'list', filters.map(pathe_M_eThtNZ.n));
                     await rstest.listTests({
                         filesOnly: options.filesOnly,
                         json: options.json
@@ -2091,7 +2090,7 @@ ${section.body}` : section.body).join("\n\n"));
             if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
         }
         function showRstest() {
-            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.greet("  Rstest v0.4.1");
+            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.greet("  Rstest v0.5.0");
             _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.log('');
         }
     },
@@ -2101,32 +2100,32 @@ ${section.body}` : section.body).join("\n\n"));
             Z9: ()=>loadConfig,
             wX: ()=>withDefaultConfig
         });
-        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("fs");
+        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
         var _rsbuild_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("@rsbuild/core");
-        var pathe__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("pathe");
-        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
-        const findConfig = (basePath)=>_utils__WEBPACK_IMPORTED_MODULE_3__.kv.map((ext)=>basePath + ext).find(node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].existsSync);
+        var pathe__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
+        var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/utils/index.ts");
+        const findConfig = (basePath)=>_utils__WEBPACK_IMPORTED_MODULE_2__.kv.map((ext)=>basePath + ext).find(node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].existsSync);
         const resolveConfigPath = (root, customConfig)=>{
             if (customConfig) {
-                const customConfigPath = (0, pathe__WEBPACK_IMPORTED_MODULE_2__.isAbsolute)(customConfig) ? customConfig : (0, pathe__WEBPACK_IMPORTED_MODULE_2__.join)(root, customConfig);
+                const customConfigPath = (0, pathe__WEBPACK_IMPORTED_MODULE_3__.i)(customConfig) ? customConfig : (0, pathe__WEBPACK_IMPORTED_MODULE_3__.j)(root, customConfig);
                 if (node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].existsSync(customConfigPath)) return customConfigPath;
-                throw `Cannot find config file: ${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.dim(customConfigPath)}`;
+                throw `Cannot find config file: ${_utils__WEBPACK_IMPORTED_MODULE_2__.yW.dim(customConfigPath)}`;
             }
-            const configFilePath = findConfig((0, pathe__WEBPACK_IMPORTED_MODULE_2__.join)(root, _utils__WEBPACK_IMPORTED_MODULE_3__.t));
+            const configFilePath = findConfig((0, pathe__WEBPACK_IMPORTED_MODULE_3__.j)(root, _utils__WEBPACK_IMPORTED_MODULE_2__.t));
             if (configFilePath) return configFilePath;
             return null;
         };
         async function loadConfig({ cwd = process.cwd(), path, envMode, configLoader }) {
             const configFilePath = resolveConfigPath(cwd, path);
             if (!configFilePath) {
-                _utils__WEBPACK_IMPORTED_MODULE_3__.vF.debug('no rstest config file found');
+                _utils__WEBPACK_IMPORTED_MODULE_2__.vF.debug('no rstest config file found');
                 return {
                     content: {},
                     filePath: configFilePath
                 };
             }
             const { content } = await (0, _rsbuild_core__WEBPACK_IMPORTED_MODULE_1__.loadConfig)({
-                cwd: (0, pathe__WEBPACK_IMPORTED_MODULE_2__.dirname)(configFilePath),
+                cwd: (0, pathe__WEBPACK_IMPORTED_MODULE_3__.d)(configFilePath),
                 path: configFilePath,
                 envMode,
                 loader: configLoader
@@ -2136,18 +2135,37 @@ ${section.body}` : section.body).join("\n\n"));
                 filePath: configFilePath
             };
         }
-        const mergeRstestConfig = (...configs)=>(0, _rsbuild_core__WEBPACK_IMPORTED_MODULE_1__.mergeRsbuildConfig)(...configs);
+        const mergeRstestConfig = (...configs)=>configs.reduce((result, config)=>{
+                const merged = (0, _rsbuild_core__WEBPACK_IMPORTED_MODULE_1__.mergeRsbuildConfig)(result, {
+                    ...config,
+                    exclude: Array.isArray(config.exclude) ? {
+                        patterns: config.exclude,
+                        override: false
+                    } : config.exclude
+                });
+                if (!Array.isArray(config.exclude) && config.exclude?.override) merged.exclude = {
+                    patterns: config.exclude.patterns
+                };
+                merged.include = config.include ?? merged.include;
+                merged.reporters = config.reporters ?? merged.reporters;
+                if (merged.coverage) merged.coverage.reporters = config.coverage?.reporters ?? merged.coverage?.reporters;
+                return merged;
+            }, {});
         const createDefaultConfig = ()=>({
                 root: process.cwd(),
                 name: 'rstest',
                 include: [
                     '**/*.{test,spec}.?(c|m)[jt]s?(x)'
                 ],
-                exclude: [
-                    '**/node_modules/**',
-                    '**/dist/**',
-                    '**/.{idea,git,cache,output,temp}/**'
-                ],
+                exclude: {
+                    patterns: [
+                        '**/node_modules/**',
+                        '**/dist/**',
+                        '**/.{idea,git,cache,output,temp}/**'
+                    ],
+                    override: false
+                },
+                setupFiles: [],
                 includeSource: [],
                 pool: {
                     type: 'forks'
@@ -2178,10 +2196,12 @@ ${section.body}` : section.body).join("\n\n"));
                 coverage: {
                     exclude: [
                         '**/node_modules/**',
+                        '**/[.]*',
                         '**/dist/**',
                         '**/test/**',
                         '**/__tests__/**',
                         '**/__mocks__/**',
+                        '**/*.d.ts',
                         '**/*.{test,spec}.[jt]s',
                         '**/*.{test,spec}.[c|m][jt]s',
                         '**/*.{test,spec}.[jt]sx',
@@ -2201,19 +2221,23 @@ ${section.body}` : section.body).join("\n\n"));
             });
         const withDefaultConfig = (config)=>{
             const merged = mergeRstestConfig(createDefaultConfig(), config);
-            merged.include = config.include || merged.include;
-            merged.exclude = (config.exclude || merged.exclude || []).concat([
-                _utils__WEBPACK_IMPORTED_MODULE_3__.EJ
-            ]);
-            merged.reporters = config.reporters ?? merged.reporters;
-            merged.coverage ??= {};
-            merged.coverage.reporters = config.coverage?.reporters ?? merged.coverage?.reporters;
-            const reportsDirectory = merged.coverage.reportsDirectory;
-            merged.coverage.reportsDirectory = (0, pathe__WEBPACK_IMPORTED_MODULE_2__.isAbsolute)(reportsDirectory) ? reportsDirectory : (0, pathe__WEBPACK_IMPORTED_MODULE_2__.resolve)(merged.root, reportsDirectory);
+            merged.setupFiles = (0, _utils__WEBPACK_IMPORTED_MODULE_2__.bg)(merged.setupFiles);
+            merged.exclude.patterns.push(_utils__WEBPACK_IMPORTED_MODULE_2__.EJ);
+            const reportsDirectory = (0, _utils__WEBPACK_IMPORTED_MODULE_2__.tS)(merged.coverage.reportsDirectory, merged.root);
+            merged.coverage.reportsDirectory = (0, pathe__WEBPACK_IMPORTED_MODULE_3__.i)(reportsDirectory) ? reportsDirectory : (0, pathe__WEBPACK_IMPORTED_MODULE_3__.r)(merged.root, reportsDirectory);
             merged.pool = 'string' == typeof config.pool ? {
                 type: config.pool
             } : merged.pool;
-            return merged;
+            return {
+                ...merged,
+                include: merged.include.map((p)=>(0, _utils__WEBPACK_IMPORTED_MODULE_2__.tS)(p, merged.root)),
+                exclude: {
+                    ...merged.exclude,
+                    patterns: merged.exclude.patterns.map((p)=>(0, _utils__WEBPACK_IMPORTED_MODULE_2__.tS)(p, merged.root))
+                },
+                setupFiles: merged.setupFiles.map((p)=>(0, _utils__WEBPACK_IMPORTED_MODULE_2__.tS)(p, merged.root)),
+                includeSource: merged.includeSource.map((p)=>(0, _utils__WEBPACK_IMPORTED_MODULE_2__.tS)(p, merged.root))
+            };
         };
     },
     "./src/utils/constants.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -2249,19 +2273,21 @@ ${section.body}` : section.body).join("\n\n"));
             bg: ()=>castArray,
             fN: ()=>getTaskNameWithPrefix,
             kV: ()=>prettyTime,
-            yW: ()=>picocolors__WEBPACK_IMPORTED_MODULE_2___default.a
+            tS: ()=>formatRootStr,
+            yW: ()=>picocolors__WEBPACK_IMPORTED_MODULE_1___default.a
         });
-        var pathe__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("pathe");
-        var picocolors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
-        var picocolors__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/ __webpack_require__.n(picocolors__WEBPACK_IMPORTED_MODULE_2__);
+        var pathe__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
+        var picocolors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        var picocolors__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(picocolors__WEBPACK_IMPORTED_MODULE_1__);
         __webpack_require__("./src/utils/constants.ts");
+        const formatRootStr = (rootStr, root)=>rootStr.replace('<rootDir>', root);
         function getAbsolutePath(base, filepath) {
-            return (0, pathe__WEBPACK_IMPORTED_MODULE_0__.isAbsolute)(filepath) ? filepath : (0, pathe__WEBPACK_IMPORTED_MODULE_0__.join)(base, filepath);
+            return (0, pathe__WEBPACK_IMPORTED_MODULE_2__.i)(filepath) ? filepath : (0, pathe__WEBPACK_IMPORTED_MODULE_2__.j)(base, filepath);
         }
         const parsePosix = (filePath)=>{
-            const { dir, base } = (0, pathe__WEBPACK_IMPORTED_MODULE_0__.parse)(filePath);
+            const { dir, base } = (0, pathe__WEBPACK_IMPORTED_MODULE_2__.p)(filePath);
             return {
-                dir: dir.split(pathe__WEBPACK_IMPORTED_MODULE_0__.sep).join('/'),
+                dir: dir.split(pathe__WEBPACK_IMPORTED_MODULE_2__.s).join('/'),
                 base
             };
         };
@@ -2414,6 +2440,7 @@ ${section.body}` : section.body).join("\n\n"));
             mT: ()=>logger.mT,
             t: ()=>constants.t,
             kV: ()=>helper.kV,
+            tS: ()=>helper.tS,
             EJ: ()=>constants.EJ,
             bg: ()=>helper.bg,
             Un: ()=>helper.Un
@@ -2421,19 +2448,19 @@ ${section.body}` : section.body).join("\n\n"));
         var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         var logger = __webpack_require__("./src/utils/logger.ts");
-        var external_node_fs_ = __webpack_require__("fs");
+        var external_node_fs_ = __webpack_require__("node:fs");
         var promises_ = __webpack_require__("node:fs/promises");
         var external_node_module_ = __webpack_require__("node:module");
-        var external_pathe_ = __webpack_require__("pathe");
-        var dist = __webpack_require__("../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs");
+        var dist = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs");
+        var tinyglobby_dist = __webpack_require__("../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs");
         const filterFiles = (testFiles, filters, dir)=>{
             if (!filters.length) return testFiles;
-            const fileFilters = 'win32' === process.platform ? filters.map((f)=>f.split(external_pathe_["default"].sep).join('/')) : filters;
+            const fileFilters = 'win32' === process.platform ? filters.map((f)=>f.split(dist.Ay.sep).join('/')) : filters;
             return testFiles.filter((t)=>{
-                const testFile = external_pathe_["default"].relative(dir, t).toLocaleLowerCase();
+                const testFile = dist.Ay.relative(dir, t).toLocaleLowerCase();
                 return fileFilters.some((f)=>{
-                    if (external_pathe_["default"].isAbsolute(f) && t.startsWith(f)) return true;
-                    const relativePath = f.endsWith('/') ? external_pathe_["default"].join(external_pathe_["default"].relative(dir, f), '/') : external_pathe_["default"].relative(dir, f);
+                    if (dist.Ay.isAbsolute(f) && t.startsWith(f)) return true;
+                    const relativePath = f.endsWith('/') ? dist.Ay.join(dist.Ay.relative(dir, f), '/') : dist.Ay.relative(dir, f);
                     return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
                 });
             });
@@ -2452,7 +2479,7 @@ ${section.body}` : section.body).join("\n\n"));
         const hasInSourceTestCode = (code)=>code.includes('import.meta.rstest');
         const formatTestEntryName = (name)=>name.replace(/\.*[/\\]/g, '_').replace(/\./g, '~');
         const getTestEntries = async ({ include, exclude, rootPath, projectRoot, fileFilters, includeSource })=>{
-            const testFiles = await (0, dist.glob)(include, {
+            const testFiles = await (0, tinyglobby_dist.glob)(include, {
                 cwd: projectRoot,
                 absolute: true,
                 ignore: exclude,
@@ -2460,7 +2487,7 @@ ${section.body}` : section.body).join("\n\n"));
                 expandDirectories: false
             });
             if (includeSource?.length) {
-                const sourceFiles = await (0, dist.glob)(includeSource, {
+                const sourceFiles = await (0, tinyglobby_dist.glob)(includeSource, {
                     cwd: projectRoot,
                     absolute: true,
                     ignore: exclude,
@@ -2477,7 +2504,7 @@ ${section.body}` : section.body).join("\n\n"));
                 }));
             }
             return Object.fromEntries(filterFiles(testFiles, fileFilters, rootPath).map((entry)=>{
-                const relativePath = external_pathe_["default"].relative(rootPath, entry);
+                const relativePath = dist.Ay.relative(rootPath, entry);
                 return [
                     formatTestEntryName(relativePath),
                     entry
@@ -2496,7 +2523,9 @@ ${section.body}` : section.body).join("\n\n"));
                 return;
             }
         };
-        const getSetupFiles = (setups, rootPath)=>Object.fromEntries((0, helper.bg)(setups).map((setupFile)=>{
+        const getSetupFiles = (setups, rootPath)=>{
+            if (!setups.length) return {};
+            return Object.fromEntries(setups.map((setupFile)=>{
                 const setupFilePath = (0, helper.FI)(rootPath, setupFile);
                 try {
                     if (!(0, external_node_fs_.existsSync)(setupFilePath)) {
@@ -2504,7 +2533,7 @@ ${section.body}` : section.body).join("\n\n"));
                         if (setupFilePath !== setupFile) errorMessage += helper.yW.gray(` (resolved path: ${setupFilePath})`);
                         throw errorMessage;
                     }
-                    const relativePath = external_pathe_["default"].relative(rootPath, setupFilePath);
+                    const relativePath = dist.Ay.relative(rootPath, setupFilePath);
                     return [
                         formatTestEntryName(relativePath),
                         setupFilePath
@@ -2517,13 +2546,14 @@ ${section.body}` : section.body).join("\n\n"));
                     throw err;
                 }
             }));
+        };
         const prettyTestPath = (testPath)=>{
             const { dir, base } = (0, helper.P2)(testPath);
             return `${'.' !== dir ? helper.yW.gray(`${dir}/`) : ''}${helper.yW.cyan(base)}`;
         };
         const formatTestPath = (root, testFilePath)=>{
             let testPath = testFilePath;
-            if (external_pathe_["default"].isAbsolute(testPath) && testPath.includes(root)) testPath = external_pathe_["default"].relative(root, testPath);
+            if (dist.Ay.isAbsolute(testPath) && testPath.includes(root)) testPath = dist.Ay.relative(root, testPath);
             return prettyTestPath(testPath);
         };
     },
@@ -2816,7 +2846,7 @@ ${section.body}` : section.body).join("\n\n"));
     events: function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_events__;
     },
-    fs: function(module) {
+    "node:fs": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__;
     },
     "node:fs/promises": function(module) {
@@ -2828,22 +2858,501 @@ ${section.body}` : section.body).join("\n\n"));
     "node:os": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__;
     },
-    "node:path": function(module) {
+    path: function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__;
     },
     "node:tty": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_tty_c64aab7e__;
     },
-    pathe: function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_pathe__;
+    "../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Ay: ()=>posix
+        });
+        var _shared_pathe_M_eThtNZ_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
+        const delimiter = /* @__PURE__ */ (()=>globalThis.process?.platform === "win32" ? ";" : ":")();
+        const _platforms = {
+            posix: void 0,
+            win32: void 0
+        };
+        const mix = (del = delimiter)=>new Proxy(_shared_pathe_M_eThtNZ_mjs__WEBPACK_IMPORTED_MODULE_0__._, {
+                get (_, prop) {
+                    if ("delimiter" === prop) return del;
+                    if ("posix" === prop) return posix;
+                    if ("win32" === prop) return win32;
+                    return _platforms[prop] || _shared_pathe_M_eThtNZ_mjs__WEBPACK_IMPORTED_MODULE_0__._[prop];
+                }
+            });
+        const posix = /* @__PURE__ */ mix(":");
+        const win32 = /* @__PURE__ */ mix(";");
+    },
+    "../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            _: ()=>_path,
+            b: ()=>relative,
+            c: ()=>basename,
+            d: ()=>dirname,
+            i: ()=>isAbsolute,
+            j: ()=>join,
+            n: ()=>normalize,
+            p: ()=>parse,
+            r: ()=>resolve,
+            s: ()=>sep
+        });
+        let _lazyMatch = ()=>{
+            var __lib__ = (()=>{
+                var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e)=>{
+                    for(var n in e)m(r, n, {
+                        get: e[n],
+                        enumerable: true
+                    });
+                }, H = (r, e, n, a)=>{
+                    if (e && "object" == typeof e || "function" == typeof e) for (let t of G(e))T.call(r, t) || t === n || m(r, t, {
+                        get: ()=>e[t],
+                        enumerable: !(a = V(e, t)) || a.enumerable
+                    });
+                    return r;
+                }, J = (r)=>H(m({}, "__esModule", {
+                        value: true
+                    }), r), w = {};
+                q(w, {
+                    default: ()=>re
+                });
+                var A = (r)=>Array.isArray(r), d = (r)=>"function" == typeof r, Q = (r)=>0 === r.length, W = (r)=>"number" == typeof r, K = (r)=>"object" == typeof r && null !== r, X = (r)=>r instanceof RegExp, b = (r)=>"string" == typeof r, h = (r)=>void 0 === r, Y = (r)=>{
+                    const e = new Map;
+                    return (n)=>{
+                        const a = e.get(n);
+                        if (a) return a;
+                        const t = r(n);
+                        return e.set(n, t), t;
+                    };
+                }, rr = (r, e, n = {})=>{
+                    const a = {
+                        cache: {},
+                        input: r,
+                        index: 0,
+                        indexMax: 0,
+                        options: n,
+                        output: []
+                    };
+                    if (v(e)(a) && a.index === r.length) return a.output;
+                    throw new Error(`Failed to parse at index ${a.indexMax}`);
+                }, i = (r, e)=>A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e)=>{
+                    const n = {};
+                    for (const a of r){
+                        if (1 !== a.length) throw new Error(`Invalid character: "${a}"`);
+                        const t = a.charCodeAt(0);
+                        n[t] = true;
+                    }
+                    return (a)=>{
+                        const t = a.index, o = a.input;
+                        for(; a.index < o.length && o.charCodeAt(a.index) in n;)a.index += 1;
+                        const u = a.index;
+                        if (u > t) {
+                            if (!h(e) && !a.options.silent) {
+                                const s = a.input.slice(t, u), c = d(e) ? e(s, o, String(t)) : e;
+                                h(c) || a.output.push(c);
+                            }
+                            a.indexMax = Math.max(a.indexMax, a.index);
+                        }
+                        return true;
+                    };
+                }, nr = (r, e)=>{
+                    const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+                    return g((o)=>{
+                        t.lastIndex = o.index;
+                        const u = t.exec(o.input);
+                        if (!u) return false;
+                        if (!h(e) && !o.options.silent) {
+                            const s = d(e) ? e(...u, o.input, String(o.index)) : e;
+                            h(s) || o.output.push(s);
+                        }
+                        return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
+                    });
+                }, ar = (r, e)=>(n)=>{
+                        if (!n.input.startsWith(r, n.index)) return false;
+                        if (!h(e) && !n.options.silent) {
+                            const t = d(e) ? e(r, n.input, String(n.index)) : e;
+                            h(t) || n.output.push(t);
+                        }
+                        return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+                    }, C = (r, e, n, a)=>{
+                    const t = v(r);
+                    return g(_(M((o)=>{
+                        let u = 0;
+                        for(; u < n;){
+                            const s = o.index;
+                            if (!t(o) || (u += 1, o.index === s)) break;
+                        }
+                        return u >= e;
+                    })));
+                }, tr = (r, e)=>C(r, 0, 1), f = (r, e)=>C(r, 0, 1 / 0), x = (r, e)=>{
+                    const n = r.map(v);
+                    return g(_(M((a)=>{
+                        for(let t = 0, o = n.length; t < o; t++)if (!n[t](a)) return false;
+                        return true;
+                    })));
+                }, l = (r, e)=>{
+                    const n = r.map(v);
+                    return g(_((a)=>{
+                        for(let t = 0, o = n.length; t < o; t++)if (n[t](a)) return true;
+                        return false;
+                    }));
+                }, M = (r, e = false)=>{
+                    const n = v(r);
+                    return (a)=>{
+                        const t = a.index, o = a.output.length, u = n(a);
+                        return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
+                    };
+                }, _ = (r, e)=>{
+                    const n = v(r);
+                    return n;
+                }, g = (()=>{
+                    let r = 0;
+                    return (e)=>{
+                        const n = v(e), a = r += 1;
+                        return (t)=>{
+                            var o;
+                            if (false === t.options.memoization) return n(t);
+                            const u = t.index, s = (o = t.cache)[a] || (o[a] = new Map), c = s.get(u);
+                            if (false === c) return false;
+                            if (W(c)) return t.index = c, true;
+                            if (c) return t.index = c.index, c.output?.length && t.output.push(...c.output), true;
+                            {
+                                const Z = t.output.length;
+                                if (!n(t)) return s.set(u, false), false;
+                                {
+                                    const D = t.index, U = t.output.length;
+                                    if (U > Z) {
+                                        const ee = t.output.slice(Z, U);
+                                        s.set(u, {
+                                            index: D,
+                                            output: ee
+                                        });
+                                    } else s.set(u, D);
+                                    return true;
+                                }
+                            }
+                        };
+                    };
+                })(), E = (r)=>{
+                    let e;
+                    return (n)=>(e || (e = v(r())), e(n));
+                }, v = Y((r)=>{
+                    if (d(r)) return Q(r) ? E(r) : r;
+                    if (b(r) || X(r)) return i(r);
+                    if (A(r)) return x(r);
+                    if (K(r)) return l(Object.values(r));
+                    throw new Error("Invalid rule");
+                }), P = "abcdefghijklmnopqrstuvwxyz", ir = (r)=>{
+                    let e = "";
+                    for(; r > 0;){
+                        const n = (r - 1) % 26;
+                        e = P[n] + e, r = Math.floor((r - 1) / 26);
+                    }
+                    return e;
+                }, O = (r)=>{
+                    let e = 0;
+                    for(let n = 0, a = r.length; n < a; n++)e = 26 * e + P.indexOf(r[n]) + 1;
+                    return e;
+                }, S = (r, e)=>{
+                    if (e < r) return S(e, r);
+                    const n = [];
+                    for(; r <= e;)n.push(r++);
+                    return n;
+                }, or = (r, e, n)=>S(r, e).map((a)=>String(a).padStart(n, "0")), R = (r, e)=>S(O(r), O(e)).map(ir), p = (r)=>r, z = (r)=>ur((e)=>rr(e, r, {
+                            memoization: false
+                        }).join("")), ur = (r)=>{
+                    const e = {};
+                    return (n)=>e[n] ?? (e[n] = r(n));
+                }, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n)=>`.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a)=>`.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r)=>`\\${r}`), vr = i(/./, p), hr = i(/^(?:!!)*!(.*)$/, (r, e)=>`(?!^${L(e)}$).*?`), dr = i(/^(!!)+/, ""), fr = l([
+                    hr,
+                    dr
+                ]), xr = i(/\/(\*\*\/)+/, "(?:/.+/|/)"), gr = i(/^(\*\*\/)+/, "(?:^|.*/)"), mr = i(/\/(\*\*)$/, "(?:/.*|$)"), _r = i(/\*\*/, ".*"), j = l([
+                    xr,
+                    gr,
+                    mr,
+                    _r
+                ]), Sr = i(/\*\/(?!\*\*\/)/, "[^/]*/"), yr = i(/\*/, "[^/]*"), N = l([
+                    Sr,
+                    yr
+                ]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Cr = i(/[$.*+?^(){}[\|]/, (r)=>`\\${r}`), Mr = i(/[^\]]/, p), Er = l([
+                    y,
+                    Cr,
+                    br,
+                    Mr
+                ]), B = x([
+                    $r,
+                    tr(Ar),
+                    f(Er),
+                    wr
+                ]), Pr = i("{", "(?:"), Or = i("}", ")"), Rr = i(/(\d+)\.\.(\d+)/, (r, e, n)=>or(+e, +n, Math.min(e.length, n.length)).join("|")), zr = i(/([a-z]+)\.\.([a-z]+)/, (r, e, n)=>R(e, n).join("|")), jr = i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n)=>R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase()), Nr = l([
+                    Rr,
+                    zr,
+                    jr
+                ]), I = x([
+                    Pr,
+                    Nr,
+                    Or
+                ]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r)=>`\\${r}`), Lr = i(/[^}]/, p), Zr = E(()=>F), Dr = l([
+                    j,
+                    N,
+                    k,
+                    B,
+                    I,
+                    Zr,
+                    y,
+                    Fr,
+                    Ir,
+                    Lr
+                ]), F = x([
+                    kr,
+                    f(Dr),
+                    Br
+                ]), Ur = f(l([
+                    sr,
+                    cr,
+                    lr,
+                    fr,
+                    j,
+                    N,
+                    k,
+                    B,
+                    I,
+                    F,
+                    y,
+                    pr,
+                    vr
+                ])), Vr = Ur, Gr = z(Vr), L = Gr, Tr = i(/\\./, p), qr = i(/./, p), Hr = i(/\*\*\*+/, "*"), Jr = i(/([^/{[(!])\*\*/, (r, e)=>`${e}*`), Qr = i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e)=>`${e}*`), Wr = f(l([
+                    Tr,
+                    Hr,
+                    Jr,
+                    Qr,
+                    qr
+                ])), Kr = Wr, Xr = z(Kr), Yr = Xr, $ = (r, e)=>{
+                    const n = Array.isArray(r) ? r : [
+                        r
+                    ];
+                    if (!n.length) return false;
+                    const a = n.map($.compile), t = n.every((s)=>/(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
+                    return a.some((s)=>s.test(o));
+                };
+                $.compile = (r)=>new RegExp(`^${L(Yr(r))}$`, "s");
+                var re = $;
+                return J(w);
+            })();
+            return __lib__.default || __lib__;
+        };
+        let _match;
+        const zeptomatch = (path, pattern)=>{
+            if (!_match) {
+                _match = _lazyMatch();
+                _lazyMatch = null;
+            }
+            return _match(path, pattern);
+        };
+        const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+        function normalizeWindowsPath(input = "") {
+            if (!input) return input;
+            return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r)=>r.toUpperCase());
+        }
+        const _UNC_REGEX = /^[/\\]{2}/;
+        const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+        const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+        const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+        const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+        const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+        const sep = "/";
+        const normalize = function(path) {
+            if (0 === path.length) return ".";
+            path = normalizeWindowsPath(path);
+            const isUNCPath = path.match(_UNC_REGEX);
+            const isPathAbsolute = isAbsolute(path);
+            const trailingSeparator = "/" === path[path.length - 1];
+            path = normalizeString(path, !isPathAbsolute);
+            if (0 === path.length) {
+                if (isPathAbsolute) return "/";
+                return trailingSeparator ? "./" : ".";
+            }
+            if (trailingSeparator) path += "/";
+            if (_DRIVE_LETTER_RE.test(path)) path += "/";
+            if (isUNCPath) {
+                if (!isPathAbsolute) return `//./${path}`;
+                return `//${path}`;
+            }
+            return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+        };
+        const join = function(...segments) {
+            let path = "";
+            for (const seg of segments)if (seg) if (path.length > 0) {
+                const pathTrailing = "/" === path[path.length - 1];
+                const segLeading = "/" === seg[0];
+                const both = pathTrailing && segLeading;
+                if (both) path += seg.slice(1);
+                else path += pathTrailing || segLeading ? seg : `/${seg}`;
+            } else path += seg;
+            return normalize(path);
+        };
+        function cwd() {
+            if ("undefined" != typeof process && "function" == typeof process.cwd) return process.cwd().replace(/\\/g, "/");
+            return "/";
+        }
+        const resolve = function(...arguments_) {
+            arguments_ = arguments_.map((argument)=>normalizeWindowsPath(argument));
+            let resolvedPath = "";
+            let resolvedAbsolute = false;
+            for(let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--){
+                const path = index >= 0 ? arguments_[index] : cwd();
+                if (path && 0 !== path.length) {
+                    resolvedPath = `${path}/${resolvedPath}`;
+                    resolvedAbsolute = isAbsolute(path);
+                }
+            }
+            resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+            if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+            return resolvedPath.length > 0 ? resolvedPath : ".";
+        };
+        function normalizeString(path, allowAboveRoot) {
+            let res = "";
+            let lastSegmentLength = 0;
+            let lastSlash = -1;
+            let dots = 0;
+            let char = null;
+            for(let index = 0; index <= path.length; ++index){
+                if (index < path.length) char = path[index];
+                else if ("/" === char) break;
+                else char = "/";
+                if ("/" === char) {
+                    if (lastSlash === index - 1 || 1 === dots) ;
+                    else if (2 === dots) {
+                        if (res.length < 2 || 2 !== lastSegmentLength || "." !== res[res.length - 1] || "." !== res[res.length - 2]) {
+                            if (res.length > 2) {
+                                const lastSlashIndex = res.lastIndexOf("/");
+                                if (-1 === lastSlashIndex) {
+                                    res = "";
+                                    lastSegmentLength = 0;
+                                } else {
+                                    res = res.slice(0, lastSlashIndex);
+                                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                                }
+                                lastSlash = index;
+                                dots = 0;
+                                continue;
+                            } else if (res.length > 0) {
+                                res = "";
+                                lastSegmentLength = 0;
+                                lastSlash = index;
+                                dots = 0;
+                                continue;
+                            }
+                        }
+                        if (allowAboveRoot) {
+                            res += res.length > 0 ? "/.." : "..";
+                            lastSegmentLength = 2;
+                        }
+                    } else {
+                        if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+                        else res = path.slice(lastSlash + 1, index);
+                        lastSegmentLength = index - lastSlash - 1;
+                    }
+                    lastSlash = index;
+                    dots = 0;
+                } else if ("." === char && -1 !== dots) ++dots;
+                else dots = -1;
+            }
+            return res;
+        }
+        const isAbsolute = function(p) {
+            return _IS_ABSOLUTE_RE.test(p);
+        };
+        const toNamespacedPath = function(p) {
+            return normalizeWindowsPath(p);
+        };
+        const extname = function(p) {
+            if (".." === p) return "";
+            const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+            return match && match[1] || "";
+        };
+        const relative = function(from, to) {
+            const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+            const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+            if (":" === _to[0][1] && ":" === _from[0][1] && _from[0] !== _to[0]) return _to.join("/");
+            const _fromCopy = [
+                ..._from
+            ];
+            for (const segment of _fromCopy){
+                if (_to[0] !== segment) break;
+                _from.shift();
+                _to.shift();
+            }
+            return [
+                ..._from.map(()=>".."),
+                ..._to
+            ].join("/");
+        };
+        const dirname = function(p) {
+            const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+            if (1 === segments.length && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+            return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+        };
+        const format = function(p) {
+            const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+            const segments = [
+                p.root,
+                p.dir,
+                p.base ?? (p.name ?? "") + ext
+            ].filter(Boolean);
+            return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+        };
+        const basename = function(p, extension) {
+            const segments = normalizeWindowsPath(p).split("/");
+            let lastSegment = "";
+            for(let i = segments.length - 1; i >= 0; i--){
+                const val = segments[i];
+                if (val) {
+                    lastSegment = val;
+                    break;
+                }
+            }
+            return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+        };
+        const parse = function(p) {
+            const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+            const base = basename(p);
+            const extension = extname(base);
+            return {
+                root,
+                dir: dirname(p),
+                base,
+                ext: extension,
+                name: base.slice(0, base.length - extension.length)
+            };
+        };
+        const matchesGlob = (path, pattern)=>zeptomatch(pattern, normalize(path));
+        const _path = {
+            __proto__: null,
+            basename: basename,
+            dirname: dirname,
+            extname: extname,
+            format: format,
+            isAbsolute: isAbsolute,
+            join: join,
+            matchesGlob: matchesGlob,
+            normalize: normalize,
+            normalizeString: normalizeString,
+            parse: parse,
+            relative: relative,
+            resolve: resolve,
+            sep: sep,
+            toNamespacedPath: toNamespacedPath
+        };
     },
     "../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             ey: ()=>isDynamicPattern,
             glob: ()=>glob
         });
-        var external_node_fs_ = __webpack_require__("fs");
-        var external_node_path_ = __webpack_require__("node:path");
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var external_node_path_ = __webpack_require__("path");
         var __require = /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_module__.createRequire)(import.meta.url);
         function cleanPath(path) {
             let normalized = (0, external_node_path_.normalize)(path);