@rstest/core 0.0.1

package/dist/cli.js

@@ -0,0 +1,3685 @@
+import external_process_default from "process";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core_1b356efc__ from "@rsbuild/core";
+import * as __WEBPACK_EXTERNAL_MODULE__vitest_snapshot_manager_ed2bcef6__ from "@vitest/snapshot/manager";
+import * as __WEBPACK_EXTERNAL_MODULE_birpc__ from "birpc";
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
+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_url_e96de089__ from "node:url";
+import * as __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__ from "node:util";
+import * as __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__ from "node:v8";
+import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_pathe__ from "pathe";
+import * as __WEBPACK_EXTERNAL_MODULE_std_env_1c7b8267__ from "std-env";
+import * as __WEBPACK_EXTERNAL_MODULE_tinypool__ from "tinypool";
+import * as __WEBPACK_EXTERNAL_MODULE_tty__ from "tty";
+import { EventEmitter } from "events";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/async.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.callback = exports.promise = void 0;
+        const walker_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/walker.js");
+        function promise(root, options) {
+            return new Promise((resolve, reject)=>{
+                callback(root, options, (err, output)=>{
+                    if (err) return reject(err);
+                    resolve(output);
+                });
+            });
+        }
+        exports.promise = promise;
+        function callback(root, options, callback) {
+            let walker = new walker_1.Walker(root, options, callback);
+            walker.start();
+        }
+        exports.callback = callback;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/counter.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Counter = void 0;
+        class Counter {
+            _files = 0;
+            _directories = 0;
+            set files(num) {
+                this._files = num;
+            }
+            get files() {
+                return this._files;
+            }
+            set directories(num) {
+                this._directories = num;
+            }
+            get directories() {
+                return this._directories;
+            }
+            get dirs() {
+                return this._directories;
+            }
+        }
+        exports.Counter = Counter;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/get-array.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const getArray = (paths)=>paths;
+        const getArrayGroup = ()=>[
+                ""
+            ].slice(0, 0);
+        function build(options) {
+            return options.group ? getArrayGroup : getArray;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/group-files.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const groupFiles = (groups, directory, files)=>{
+            groups.push({
+                directory,
+                files,
+                dir: directory
+            });
+        };
+        const empty = ()=>{};
+        function build(options) {
+            return options.group ? groupFiles : empty;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/invoke-callback.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const onlyCountsSync = (state)=>state.counts;
+        const groupsSync = (state)=>state.groups;
+        const defaultSync = (state)=>state.paths;
+        const limitFilesSync = (state)=>state.paths.slice(0, state.options.maxFiles);
+        const onlyCountsAsync = (state, error, callback)=>{
+            report(error, callback, state.counts, state.options.suppressErrors);
+            return null;
+        };
+        const defaultAsync = (state, error, callback)=>{
+            report(error, callback, state.paths, state.options.suppressErrors);
+            return null;
+        };
+        const limitFilesAsync = (state, error, callback)=>{
+            report(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+            return null;
+        };
+        const groupsAsync = (state, error, callback)=>{
+            report(error, callback, state.groups, state.options.suppressErrors);
+            return null;
+        };
+        function report(error, callback, output, suppressErrors) {
+            callback(error && !suppressErrors ? error : null, output);
+        }
+        function build(options, isSynchronous) {
+            const { onlyCounts, group, maxFiles } = options;
+            if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+            if (group) return isSynchronous ? groupsSync : groupsAsync;
+            if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+            return isSynchronous ? defaultSync : defaultAsync;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/join-path.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = exports.joinDirectoryPath = exports.joinPathWithBasePath = void 0;
+        const path_1 = __webpack_require__("path");
+        const utils_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/utils.js");
+        function joinPathWithBasePath(filename, directoryPath) {
+            return directoryPath + filename;
+        }
+        exports.joinPathWithBasePath = joinPathWithBasePath;
+        function joinPathWithRelativePath(root, options) {
+            return function(filename, directoryPath) {
+                const sameRoot = directoryPath.startsWith(root);
+                if (sameRoot) return directoryPath.replace(root, "") + filename;
+                return (0, utils_1.convertSlashes)((0, path_1.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+            };
+        }
+        function joinPath(filename) {
+            return filename;
+        }
+        function joinDirectoryPath(filename, directoryPath, separator) {
+            return directoryPath + filename + separator;
+        }
+        exports.joinDirectoryPath = joinDirectoryPath;
+        function build(root, options) {
+            const { relativePaths, includeBasePath } = options;
+            return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-directory.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        function pushDirectoryWithRelativePath(root) {
+            return function(directoryPath, paths) {
+                paths.push(directoryPath.substring(root.length) || ".");
+            };
+        }
+        function pushDirectoryFilterWithRelativePath(root) {
+            return function(directoryPath, paths, filters) {
+                const relativePath = directoryPath.substring(root.length) || ".";
+                if (filters.every((filter)=>filter(relativePath, true))) paths.push(relativePath);
+            };
+        }
+        const pushDirectory = (directoryPath, paths)=>{
+            paths.push(directoryPath || ".");
+        };
+        const pushDirectoryFilter = (directoryPath, paths, filters)=>{
+            const path = directoryPath || ".";
+            if (filters.every((filter)=>filter(path, true))) paths.push(path);
+        };
+        const empty = ()=>{};
+        function build(root, options) {
+            const { includeDirs, filters, relativePaths } = options;
+            if (!includeDirs) return empty;
+            if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+            return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-file.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const pushFileFilterAndCount = (filename, _paths, counts, filters)=>{
+            if (filters.every((filter)=>filter(filename, false))) counts.files++;
+        };
+        const pushFileFilter = (filename, paths, _counts, filters)=>{
+            if (filters.every((filter)=>filter(filename, false))) paths.push(filename);
+        };
+        const pushFileCount = (_filename, _paths, counts, _filters)=>{
+            counts.files++;
+        };
+        const pushFile = (filename, paths)=>{
+            paths.push(filename);
+        };
+        const empty = ()=>{};
+        function build(options) {
+            const { excludeFiles, filters, onlyCounts } = options;
+            if (excludeFiles) return empty;
+            if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+            if (onlyCounts) return pushFileCount;
+            return pushFile;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/resolve-symlink.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const fs_1 = __importDefault(__webpack_require__("fs"));
+        const path_1 = __webpack_require__("path");
+        const resolveSymlinksAsync = function(path, state, callback) {
+            const { queue, options: { suppressErrors } } = state;
+            queue.enqueue();
+            fs_1.default.realpath(path, (error, resolvedPath)=>{
+                if (error) return queue.dequeue(suppressErrors ? null : error, state);
+                fs_1.default.stat(resolvedPath, (error, stat)=>{
+                    if (error) return queue.dequeue(suppressErrors ? null : error, state);
+                    if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+                    callback(stat, resolvedPath);
+                    queue.dequeue(null, state);
+                });
+            });
+        };
+        const resolveSymlinks = function(path, state, callback) {
+            const { queue, options: { suppressErrors } } = state;
+            queue.enqueue();
+            try {
+                const resolvedPath = fs_1.default.realpathSync(path);
+                const stat = fs_1.default.statSync(resolvedPath);
+                if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+                callback(stat, resolvedPath);
+            } catch (e) {
+                if (!suppressErrors) throw e;
+            }
+        };
+        function build(options, isSynchronous) {
+            if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+            return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+        }
+        exports.build = build;
+        function isRecursive(path, resolved, state) {
+            if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+            let parent = (0, path_1.dirname)(path);
+            let depth = 1;
+            while(parent !== state.root && depth < 2){
+                const resolvedPath = state.symlinks.get(parent);
+                const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+                if (isSameRoot) depth++;
+                else parent = (0, path_1.dirname)(parent);
+            }
+            state.symlinks.set(path, resolved);
+            return depth > 1;
+        }
+        function isRecursiveUsingRealPaths(resolved, state) {
+            return state.visited.includes(resolved + state.options.pathSeparator);
+        }
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/walk-directory.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const fs_1 = __importDefault(__webpack_require__("fs"));
+        const readdirOpts = {
+            withFileTypes: true
+        };
+        const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback)=>{
+            if (currentDepth < 0) return state.queue.dequeue(null, state);
+            state.visited.push(crawlPath);
+            state.counts.directories++;
+            state.queue.enqueue();
+            fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = [])=>{
+                callback(entries, directoryPath, currentDepth);
+                state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+            });
+        };
+        const walkSync = (state, crawlPath, directoryPath, currentDepth, callback)=>{
+            if (currentDepth < 0) return;
+            state.visited.push(crawlPath);
+            state.counts.directories++;
+            let entries = [];
+            try {
+                entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
+            } catch (e) {
+                if (!state.options.suppressErrors) throw e;
+            }
+            callback(entries, directoryPath, currentDepth);
+        };
+        function build(isSynchronous) {
+            return isSynchronous ? walkSync : walkAsync;
+        }
+        exports.build = build;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/queue.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Queue = void 0;
+        class Queue {
+            onQueueEmpty;
+            count = 0;
+            constructor(onQueueEmpty){
+                this.onQueueEmpty = onQueueEmpty;
+            }
+            enqueue() {
+                this.count++;
+            }
+            dequeue(error, output) {
+                if (--this.count <= 0 || error) this.onQueueEmpty(error, output);
+            }
+        }
+        exports.Queue = Queue;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/sync.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.sync = void 0;
+        const walker_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/walker.js");
+        function sync(root, options) {
+            const walker = new walker_1.Walker(root, options);
+            return walker.start();
+        }
+        exports.sync = sync;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/walker.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) 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];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) 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(mod) {
+            if (mod && mod.__esModule) return mod;
+            var result = {};
+            if (null != mod) {
+                for(var k in mod)if ("default" !== k && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+            }
+            __setModuleDefault(result, mod);
+            return result;
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Walker = void 0;
+        const path_1 = __webpack_require__("path");
+        const utils_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/utils.js");
+        const joinPath = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/join-path.js"));
+        const pushDirectory = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-directory.js"));
+        const pushFile = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-file.js"));
+        const getArray = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/get-array.js"));
+        const groupFiles = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/group-files.js"));
+        const resolveSymlink = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/resolve-symlink.js"));
+        const invokeCallback = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/invoke-callback.js"));
+        const walkDirectory = __importStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/functions/walk-directory.js"));
+        const queue_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/queue.js");
+        const counter_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/counter.js");
+        class Walker {
+            root;
+            isSynchronous;
+            state;
+            joinPath;
+            pushDirectory;
+            pushFile;
+            getArray;
+            groupFiles;
+            resolveSymlink;
+            walkDirectory;
+            callbackInvoker;
+            constructor(root, options, callback){
+                this.isSynchronous = !callback;
+                this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
+                this.root = (0, utils_1.normalizePath)(root, options);
+                this.state = {
+                    root: (0, utils_1.isRootDirectory)(this.root) ? this.root : this.root.slice(0, -1),
+                    paths: [
+                        ""
+                    ].slice(0, 0),
+                    groups: [],
+                    counts: new counter_1.Counter(),
+                    options,
+                    queue: new queue_1.Queue((error, state)=>this.callbackInvoker(state, error, callback)),
+                    symlinks: new Map(),
+                    visited: [
+                        ""
+                    ].slice(0, 0)
+                };
+                this.joinPath = joinPath.build(this.root, options);
+                this.pushDirectory = pushDirectory.build(this.root, options);
+                this.pushFile = pushFile.build(options);
+                this.getArray = getArray.build(options);
+                this.groupFiles = groupFiles.build(options);
+                this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
+                this.walkDirectory = walkDirectory.build(this.isSynchronous);
+            }
+            start() {
+                this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+                return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+            }
+            walk = (entries, directoryPath, depth)=>{
+                const { paths, options: { filters, resolveSymlinks, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator } } = this.state;
+                if (signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+                this.pushDirectory(directoryPath, paths, filters);
+                const files = this.getArray(this.state.paths);
+                for(let i = 0; i < entries.length; ++i){
+                    const entry = entries[i];
+                    if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks && !excludeSymlinks) {
+                        const filename = this.joinPath(entry.name, directoryPath);
+                        this.pushFile(filename, files, this.state.counts, filters);
+                    } else if (entry.isDirectory()) {
+                        let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                        if (exclude && exclude(entry.name, path)) continue;
+                        this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+                    } else if (entry.isSymbolicLink() && this.resolveSymlink) {
+                        let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+                        this.resolveSymlink(path, this.state, (stat, resolvedPath)=>{
+                            if (stat.isDirectory()) {
+                                resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
+                                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+                                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                            } else {
+                                resolvedPath = useRealPaths ? resolvedPath : path;
+                                const filename = (0, path_1.basename)(resolvedPath);
+                                const directoryPath = (0, utils_1.normalizePath)((0, path_1.dirname)(resolvedPath), this.state.options);
+                                resolvedPath = this.joinPath(filename, directoryPath);
+                                this.pushFile(resolvedPath, files, this.state.counts, filters);
+                            }
+                        });
+                    }
+                }
+                this.groupFiles(this.state.groups, directoryPath, files);
+            };
+        }
+        exports.Walker = Walker;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/builder/api-builder.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.APIBuilder = void 0;
+        const async_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/async.js");
+        const sync_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/api/sync.js");
+        class APIBuilder {
+            root;
+            options;
+            constructor(root, options){
+                this.root = root;
+                this.options = options;
+            }
+            withPromise() {
+                return (0, async_1.promise)(this.root, this.options);
+            }
+            withCallback(cb) {
+                (0, async_1.callback)(this.root, this.options, cb);
+            }
+            sync() {
+                return (0, sync_1.sync)(this.root, this.options);
+            }
+        }
+        exports.APIBuilder = APIBuilder;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/builder/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Builder = void 0;
+        const path_1 = __webpack_require__("path");
+        const api_builder_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/builder/api-builder.js");
+        var pm = null;
+        try {
+            require.resolve("picomatch");
+            pm = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/index.js");
+        } catch (_e) {}
+        class Builder {
+            globCache = {};
+            options = {
+                maxDepth: 1 / 0,
+                suppressErrors: true,
+                pathSeparator: path_1.sep,
+                filters: []
+            };
+            globFunction;
+            constructor(options){
+                this.options = {
+                    ...this.options,
+                    ...options
+                };
+                this.globFunction = this.options.globFunction;
+            }
+            group() {
+                this.options.group = true;
+                return this;
+            }
+            withPathSeparator(separator) {
+                this.options.pathSeparator = separator;
+                return this;
+            }
+            withBasePath() {
+                this.options.includeBasePath = true;
+                return this;
+            }
+            withRelativePaths() {
+                this.options.relativePaths = true;
+                return this;
+            }
+            withDirs() {
+                this.options.includeDirs = true;
+                return this;
+            }
+            withMaxDepth(depth) {
+                this.options.maxDepth = depth;
+                return this;
+            }
+            withMaxFiles(limit) {
+                this.options.maxFiles = limit;
+                return this;
+            }
+            withFullPaths() {
+                this.options.resolvePaths = true;
+                this.options.includeBasePath = true;
+                return this;
+            }
+            withErrors() {
+                this.options.suppressErrors = false;
+                return this;
+            }
+            withSymlinks({ resolvePaths = true } = {}) {
+                this.options.resolveSymlinks = true;
+                this.options.useRealPaths = resolvePaths;
+                return this.withFullPaths();
+            }
+            withAbortSignal(signal) {
+                this.options.signal = signal;
+                return this;
+            }
+            normalize() {
+                this.options.normalizePath = true;
+                return this;
+            }
+            filter(predicate) {
+                this.options.filters.push(predicate);
+                return this;
+            }
+            onlyDirs() {
+                this.options.excludeFiles = true;
+                this.options.includeDirs = true;
+                return this;
+            }
+            exclude(predicate) {
+                this.options.exclude = predicate;
+                return this;
+            }
+            onlyCounts() {
+                this.options.onlyCounts = true;
+                return this;
+            }
+            crawl(root) {
+                return new api_builder_1.APIBuilder(root || ".", this.options);
+            }
+            withGlobFunction(fn) {
+                this.globFunction = fn;
+                return this;
+            }
+            crawlWithOptions(root, options) {
+                this.options = {
+                    ...this.options,
+                    ...options
+                };
+                return new api_builder_1.APIBuilder(root || ".", this.options);
+            }
+            glob(...patterns) {
+                if (this.globFunction) return this.globWithOptions(patterns);
+                return this.globWithOptions(patterns, {
+                    dot: true
+                });
+            }
+            globWithOptions(patterns, ...options) {
+                const globFn = this.globFunction || pm;
+                if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+                var isMatch = this.globCache[patterns.join("\0")];
+                if (!isMatch) {
+                    isMatch = globFn(patterns, ...options);
+                    this.globCache[patterns.join("\0")] = isMatch;
+                }
+                this.options.filters.push((path)=>isMatch(path));
+                return this;
+            }
+        }
+        exports.Builder = Builder;
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) 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];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)if ("default" !== p && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.fdir = void 0;
+        const builder_1 = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/builder/index.js");
+        Object.defineProperty(exports, "fdir", {
+            enumerable: true,
+            get: function() {
+                return builder_1.Builder;
+            }
+        });
+        __exportStar(__webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/types.js"), exports);
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/types.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+    },
+    "../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/utils.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.normalizePath = exports.isRootDirectory = exports.convertSlashes = exports.cleanPath = void 0;
+        const path_1 = __webpack_require__("path");
+        function cleanPath(path) {
+            let normalized = (0, path_1.normalize)(path);
+            if (normalized.length > 1 && normalized[normalized.length - 1] === path_1.sep) normalized = normalized.substring(0, normalized.length - 1);
+            return normalized;
+        }
+        exports.cleanPath = cleanPath;
+        const SLASHES_REGEX = /[\\/]/g;
+        function convertSlashes(path, separator) {
+            return path.replace(SLASHES_REGEX, separator);
+        }
+        exports.convertSlashes = convertSlashes;
+        function isRootDirectory(path) {
+            return "/" === path || /^[a-z]:\\$/i.test(path);
+        }
+        exports.isRootDirectory = isRootDirectory;
+        function normalizePath(path, options) {
+            const { resolvePaths, normalizePath, pathSeparator } = options;
+            const pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
+            if (resolvePaths) path = (0, path_1.resolve)(path);
+            if (normalizePath || pathNeedsCleaning) path = cleanPath(path);
+            if ("." === path) return "";
+            const needsSeperator = path[path.length - 1] !== pathSeparator;
+            return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+        }
+        exports.normalizePath = normalizePath;
+    },
+    "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js": function(module) {
+        let p = process || {}, argv = p.argv || [], env = p.env || {};
+        let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
+        let formatter = (open, close, replace = open)=>(input)=>{
+                let string = "" + input, index = string.indexOf(close, open.length);
+                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+            };
+        let replaceClose = (string, close, replace, index)=>{
+            let result = "", cursor = 0;
+            do {
+                result += string.substring(cursor, index) + replace;
+                cursor = index + close.length;
+                index = string.indexOf(close, cursor);
+            }while (~index);
+            return result + string.substring(cursor);
+        };
+        let createColors = (enabled = isColorSupported)=>{
+            let f = enabled ? formatter : ()=>String;
+            return {
+                isColorSupported: enabled,
+                reset: f("\x1b[0m", "\x1b[0m"),
+                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+                italic: f("\x1b[3m", "\x1b[23m"),
+                underline: f("\x1b[4m", "\x1b[24m"),
+                inverse: f("\x1b[7m", "\x1b[27m"),
+                hidden: f("\x1b[8m", "\x1b[28m"),
+                strikethrough: f("\x1b[9m", "\x1b[29m"),
+                black: f("\x1b[30m", "\x1b[39m"),
+                red: f("\x1b[31m", "\x1b[39m"),
+                green: f("\x1b[32m", "\x1b[39m"),
+                yellow: f("\x1b[33m", "\x1b[39m"),
+                blue: f("\x1b[34m", "\x1b[39m"),
+                magenta: f("\x1b[35m", "\x1b[39m"),
+                cyan: f("\x1b[36m", "\x1b[39m"),
+                white: f("\x1b[37m", "\x1b[39m"),
+                gray: f("\x1b[90m", "\x1b[39m"),
+                bgBlack: f("\x1b[40m", "\x1b[49m"),
+                bgRed: f("\x1b[41m", "\x1b[49m"),
+                bgGreen: f("\x1b[42m", "\x1b[49m"),
+                bgYellow: f("\x1b[43m", "\x1b[49m"),
+                bgBlue: f("\x1b[44m", "\x1b[49m"),
+                bgMagenta: f("\x1b[45m", "\x1b[49m"),
+                bgCyan: f("\x1b[46m", "\x1b[49m"),
+                bgWhite: f("\x1b[47m", "\x1b[49m"),
+                blackBright: f("\x1b[90m", "\x1b[39m"),
+                redBright: f("\x1b[91m", "\x1b[39m"),
+                greenBright: f("\x1b[92m", "\x1b[39m"),
+                yellowBright: f("\x1b[93m", "\x1b[39m"),
+                blueBright: f("\x1b[94m", "\x1b[39m"),
+                magentaBright: f("\x1b[95m", "\x1b[39m"),
+                cyanBright: f("\x1b[96m", "\x1b[39m"),
+                whiteBright: f("\x1b[97m", "\x1b[39m"),
+                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+                bgRedBright: f("\x1b[101m", "\x1b[49m"),
+                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
+            };
+        };
+        module.exports = createColors();
+        module.exports.createColors = createColors;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/picomatch.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        function picomatch(glob, options, returnState = false) {
+            if (options && (null === options.windows || void 0 === options.windows)) options = {
+                ...options,
+                windows: utils.isWindows()
+            };
+            return pico(glob, options, returnState);
+        }
+        Object.assign(picomatch, pico);
+        module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js": function(module) {
+        const WIN_SLASH = '\\\\/';
+        const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        const DOT_LITERAL = '\\.';
+        const PLUS_LITERAL = '\\+';
+        const QMARK_LITERAL = '\\?';
+        const SLASH_LITERAL = '\\/';
+        const ONE_CHAR = '(?=.)';
+        const QMARK = '[^/]';
+        const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+        const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+        const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+        const NO_DOT = `(?!${DOT_LITERAL})`;
+        const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+        const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+        const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+        const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+        const STAR = `${QMARK}*?`;
+        const SEP = '/';
+        const POSIX_CHARS = {
+            DOT_LITERAL,
+            PLUS_LITERAL,
+            QMARK_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            QMARK,
+            END_ANCHOR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOTS,
+            NO_DOT_SLASH,
+            NO_DOTS_SLASH,
+            QMARK_NO_DOT,
+            STAR,
+            START_ANCHOR,
+            SEP
+        };
+        const WINDOWS_CHARS = {
+            ...POSIX_CHARS,
+            SLASH_LITERAL: `[${WIN_SLASH}]`,
+            QMARK: WIN_NO_SLASH,
+            STAR: `${WIN_NO_SLASH}*?`,
+            DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+            NO_DOT: `(?!${DOT_LITERAL})`,
+            NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+            NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+            START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+            END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+            SEP: '\\'
+        };
+        const POSIX_REGEX_SOURCE = {
+            alnum: 'a-zA-Z0-9',
+            alpha: 'a-zA-Z',
+            ascii: '\\x00-\\x7F',
+            blank: ' \\t',
+            cntrl: '\\x00-\\x1F\\x7F',
+            digit: '0-9',
+            graph: '\\x21-\\x7E',
+            lower: 'a-z',
+            print: '\\x20-\\x7E ',
+            punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+            space: ' \\t\\r\\n\\v\\f',
+            upper: 'A-Z',
+            word: 'A-Za-z0-9_',
+            xdigit: 'A-Fa-f0-9'
+        };
+        module.exports = {
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE,
+            REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+            REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+            REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+            REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+            REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+            REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+            REPLACEMENTS: {
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            CHAR_0: 48,
+            CHAR_9: 57,
+            CHAR_UPPERCASE_A: 65,
+            CHAR_LOWERCASE_A: 97,
+            CHAR_UPPERCASE_Z: 90,
+            CHAR_LOWERCASE_Z: 122,
+            CHAR_LEFT_PARENTHESES: 40,
+            CHAR_RIGHT_PARENTHESES: 41,
+            CHAR_ASTERISK: 42,
+            CHAR_AMPERSAND: 38,
+            CHAR_AT: 64,
+            CHAR_BACKWARD_SLASH: 92,
+            CHAR_CARRIAGE_RETURN: 13,
+            CHAR_CIRCUMFLEX_ACCENT: 94,
+            CHAR_COLON: 58,
+            CHAR_COMMA: 44,
+            CHAR_DOT: 46,
+            CHAR_DOUBLE_QUOTE: 34,
+            CHAR_EQUAL: 61,
+            CHAR_EXCLAMATION_MARK: 33,
+            CHAR_FORM_FEED: 12,
+            CHAR_FORWARD_SLASH: 47,
+            CHAR_GRAVE_ACCENT: 96,
+            CHAR_HASH: 35,
+            CHAR_HYPHEN_MINUS: 45,
+            CHAR_LEFT_ANGLE_BRACKET: 60,
+            CHAR_LEFT_CURLY_BRACE: 123,
+            CHAR_LEFT_SQUARE_BRACKET: 91,
+            CHAR_LINE_FEED: 10,
+            CHAR_NO_BREAK_SPACE: 160,
+            CHAR_PERCENT: 37,
+            CHAR_PLUS: 43,
+            CHAR_QUESTION_MARK: 63,
+            CHAR_RIGHT_ANGLE_BRACKET: 62,
+            CHAR_RIGHT_CURLY_BRACE: 125,
+            CHAR_RIGHT_SQUARE_BRACKET: 93,
+            CHAR_SEMICOLON: 59,
+            CHAR_SINGLE_QUOTE: 39,
+            CHAR_SPACE: 32,
+            CHAR_TAB: 9,
+            CHAR_UNDERSCORE: 95,
+            CHAR_VERTICAL_LINE: 124,
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+            extglobChars (chars) {
+                return {
+                    '!': {
+                        type: 'negate',
+                        open: '(?:(?!(?:',
+                        close: `))${chars.STAR})`
+                    },
+                    '?': {
+                        type: 'qmark',
+                        open: '(?:',
+                        close: ')?'
+                    },
+                    '+': {
+                        type: 'plus',
+                        open: '(?:',
+                        close: ')+'
+                    },
+                    '*': {
+                        type: 'star',
+                        open: '(?:',
+                        close: ')*'
+                    },
+                    '@': {
+                        type: 'at',
+                        open: '(?:',
+                        close: ')'
+                    }
+                };
+            },
+            globChars (win32) {
+                return true === win32 ? WINDOWS_CHARS : POSIX_CHARS;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/parse.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const constants = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+        const expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            const value = `[${args.join('-')}]`;
+            try {
+                new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        };
+        const syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        const parse = (input, options)=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            input = REPLACEMENTS[input] || input;
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            let len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            const bos = {
+                type: 'bos',
+                value: '',
+                output: opts.prepend || ''
+            };
+            const tokens = [
+                bos
+            ];
+            const capture = opts.capture ? '' : '?:';
+            const PLATFORM_CHARS = constants.globChars(opts.windows);
+            const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+            const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+            const globstar = (opts)=>`(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            const nodot = opts.dot ? '' : NO_DOT;
+            const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+            let star = true === opts.bash ? globstar(opts) : STAR;
+            if (opts.capture) star = `(${star})`;
+            if ('boolean' == typeof opts.noext) opts.noextglob = opts.noext;
+            const state = {
+                input,
+                index: -1,
+                start: 0,
+                dot: true === opts.dot,
+                consumed: '',
+                output: '',
+                prefix: '',
+                backtrack: false,
+                negated: false,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: false,
+                tokens
+            };
+            input = utils.removePrefix(input, state);
+            len = input.length;
+            const extglobs = [];
+            const braces = [];
+            const stack = [];
+            let prev = bos;
+            let value;
+            const eos = ()=>state.index === len - 1;
+            const peek = state.peek = (n = 1)=>input[state.index + n];
+            const advance = state.advance = ()=>input[++state.index] || '';
+            const remaining = ()=>input.slice(state.index + 1);
+            const consume = (value = '', num = 0)=>{
+                state.consumed += value;
+                state.index += num;
+            };
+            const append = (token)=>{
+                state.output += null != token.output ? token.output : token.value;
+                consume(token.value);
+            };
+            const negate = ()=>{
+                let count = 1;
+                while('!' === peek() && ('(' !== peek(2) || '?' === peek(3))){
+                    advance();
+                    state.start++;
+                    count++;
+                }
+                if (count % 2 === 0) return false;
+                state.negated = true;
+                state.start++;
+                return true;
+            };
+            const increment = (type)=>{
+                state[type]++;
+                stack.push(type);
+            };
+            const decrement = (type)=>{
+                state[type]--;
+                stack.pop();
+            };
+            const push = (tok)=>{
+                if ('globstar' === prev.type) {
+                    const isBrace = state.braces > 0 && ('comma' === tok.type || 'brace' === tok.type);
+                    const isExtglob = true === tok.extglob || extglobs.length && ('pipe' === tok.type || 'paren' === tok.type);
+                    if ('slash' !== tok.type && 'paren' !== tok.type && !isBrace && !isExtglob) {
+                        state.output = state.output.slice(0, -prev.output.length);
+                        prev.type = 'star';
+                        prev.value = '*';
+                        prev.output = star;
+                        state.output += prev.output;
+                    }
+                }
+                if (extglobs.length && 'paren' !== tok.type) extglobs[extglobs.length - 1].inner += tok.value;
+                if (tok.value || tok.output) append(tok);
+                if (prev && 'text' === prev.type && 'text' === tok.type) {
+                    prev.output = (prev.output || prev.value) + tok.value;
+                    prev.value += tok.value;
+                    return;
+                }
+                tok.prev = prev;
+                tokens.push(tok);
+                prev = tok;
+            };
+            const extglobOpen = (type, value)=>{
+                const token = {
+                    ...EXTGLOB_CHARS[value],
+                    conditions: 1,
+                    inner: ''
+                };
+                token.prev = prev;
+                token.parens = state.parens;
+                token.output = state.output;
+                const output = (opts.capture ? '(' : '') + token.open;
+                increment('parens');
+                push({
+                    type,
+                    value,
+                    output: state.output ? '' : ONE_CHAR
+                });
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value: advance(),
+                    output
+                });
+                extglobs.push(token);
+            };
+            const extglobClose = (token)=>{
+                let output = token.close + (opts.capture ? ')' : '');
+                let rest;
+                if ('negate' === token.type) {
+                    let extglobStar = star;
+                    if (token.inner && token.inner.length > 1 && token.inner.includes('/')) extglobStar = globstar(opts);
+                    if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
+                    if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                        const expression = parse(rest, {
+                            ...options,
+                            fastpaths: false
+                        }).output;
+                        output = token.close = `)${expression})${extglobStar})`;
+                    }
+                    if ('bos' === token.prev.type) state.negatedExtglob = true;
+                }
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value,
+                    output
+                });
+                decrement('parens');
+            };
+            if (false !== opts.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+                let backslashes = false;
+                let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>{
+                    if ('\\' === first) {
+                        backslashes = true;
+                        return m;
+                    }
+                    if ('?' === first) {
+                        if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+                        if (0 === index) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+                        return QMARK.repeat(chars.length);
+                    }
+                    if ('.' === first) return DOT_LITERAL.repeat(chars.length);
+                    if ('*' === first) {
+                        if (esc) return esc + first + (rest ? star : '');
+                        return star;
+                    }
+                    return esc ? m : `\\${m}`;
+                });
+                if (true === backslashes) output = true === opts.unescape ? output.replace(/\\/g, '') : output.replace(/\\+/g, (m)=>m.length % 2 === 0 ? '\\\\' : m ? '\\' : '');
+                if (output === input && true === opts.contains) {
+                    state.output = input;
+                    return state;
+                }
+                state.output = utils.wrapOutput(output, state, options);
+                return state;
+            }
+            while(!eos()){
+                value = advance();
+                if ('\u0000' === value) continue;
+                if ('\\' === value) {
+                    const next = peek();
+                    if ('/' === next && true !== opts.bash) continue;
+                    if ('.' === next || ';' === next) continue;
+                    if (!next) {
+                        value += '\\';
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    const match = /^\\+/.exec(remaining());
+                    let slashes = 0;
+                    if (match && match[0].length > 2) {
+                        slashes = match[0].length;
+                        state.index += slashes;
+                        if (slashes % 2 !== 0) value += '\\';
+                    }
+                    if (true === opts.unescape) value = advance();
+                    else value += advance();
+                    if (0 === state.brackets) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                }
+                if (state.brackets > 0 && (']' !== value || '[' === prev.value || '[^' === prev.value)) {
+                    if (false !== opts.posix && ':' === value) {
+                        const inner = prev.value.slice(1);
+                        if (inner.includes('[')) {
+                            prev.posix = true;
+                            if (inner.includes(':')) {
+                                const idx = prev.value.lastIndexOf('[');
+                                const pre = prev.value.slice(0, idx);
+                                const rest = prev.value.slice(idx + 2);
+                                const posix = POSIX_REGEX_SOURCE[rest];
+                                if (posix) {
+                                    prev.value = pre + posix;
+                                    state.backtrack = true;
+                                    advance();
+                                    if (!bos.output && 1 === tokens.indexOf(prev)) bos.output = ONE_CHAR;
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    if ('[' === value && ':' !== peek() || '-' === value && ']' === peek()) value = `\\${value}`;
+                    if (']' === value && ('[' === prev.value || '[^' === prev.value)) value = `\\${value}`;
+                    if (true === opts.posix && '!' === value && '[' === prev.value) value = '^';
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                if (1 === state.quotes && '"' !== value) {
+                    value = utils.escapeRegex(value);
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                if ('"' === value) {
+                    state.quotes = 1 === state.quotes ? 0 : 1;
+                    if (true === opts.keepQuotes) push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('(' === value) {
+                    increment('parens');
+                    push({
+                        type: 'paren',
+                        value
+                    });
+                    continue;
+                }
+                if (')' === value) {
+                    if (0 === state.parens && true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '('));
+                    const extglob = extglobs[extglobs.length - 1];
+                    if (extglob && state.parens === extglob.parens + 1) {
+                        extglobClose(extglobs.pop());
+                        continue;
+                    }
+                    push({
+                        type: 'paren',
+                        value,
+                        output: state.parens ? ')' : '\\)'
+                    });
+                    decrement('parens');
+                    continue;
+                }
+                if ('[' === value) {
+                    if (true !== opts.nobracket && remaining().includes(']')) increment('brackets');
+                    else {
+                        if (true !== opts.nobracket && true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                        value = `\\${value}`;
+                    }
+                    push({
+                        type: 'bracket',
+                        value
+                    });
+                    continue;
+                }
+                if (']' === value) {
+                    if (true === opts.nobracket || prev && 'bracket' === prev.type && 1 === prev.value.length) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    if (0 === state.brackets) {
+                        if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '['));
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    decrement('brackets');
+                    const prevValue = prev.value.slice(1);
+                    if (true !== prev.posix && '^' === prevValue[0] && !prevValue.includes('/')) value = `/${value}`;
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    if (false === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    const escaped = utils.escapeRegex(prev.value);
+                    state.output = state.output.slice(0, -prev.value.length);
+                    if (true === opts.literalBrackets) {
+                        state.output += escaped;
+                        prev.value = escaped;
+                        continue;
+                    }
+                    prev.value = `(${capture}${escaped}|${prev.value})`;
+                    state.output += prev.value;
+                    continue;
+                }
+                if ('{' === value && true !== opts.nobrace) {
+                    increment('braces');
+                    const open = {
+                        type: 'brace',
+                        value,
+                        output: '(',
+                        outputIndex: state.output.length,
+                        tokensIndex: state.tokens.length
+                    };
+                    braces.push(open);
+                    push(open);
+                    continue;
+                }
+                if ('}' === value) {
+                    const brace = braces[braces.length - 1];
+                    if (true === opts.nobrace || !brace) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: value
+                        });
+                        continue;
+                    }
+                    let output = ')';
+                    if (true === brace.dots) {
+                        const arr = tokens.slice();
+                        const range = [];
+                        for(let i = arr.length - 1; i >= 0; i--){
+                            tokens.pop();
+                            if ('brace' === arr[i].type) break;
+                            if ('dots' !== arr[i].type) range.unshift(arr[i].value);
+                        }
+                        output = expandRange(range, opts);
+                        state.backtrack = true;
+                    }
+                    if (true !== brace.comma && true !== brace.dots) {
+                        const out = state.output.slice(0, brace.outputIndex);
+                        const toks = state.tokens.slice(brace.tokensIndex);
+                        brace.value = brace.output = '\\{';
+                        value = output = '\\}';
+                        state.output = out;
+                        for (const t of toks)state.output += t.output || t.value;
+                    }
+                    push({
+                        type: 'brace',
+                        value,
+                        output
+                    });
+                    decrement('braces');
+                    braces.pop();
+                    continue;
+                }
+                if ('|' === value) {
+                    if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (',' === value) {
+                    let output = value;
+                    const brace = braces[braces.length - 1];
+                    if (brace && 'braces' === stack[stack.length - 1]) {
+                        brace.comma = true;
+                        output = '|';
+                    }
+                    push({
+                        type: 'comma',
+                        value,
+                        output
+                    });
+                    continue;
+                }
+                if ('/' === value) {
+                    if ('dot' === prev.type && state.index === state.start + 1) {
+                        state.start = state.index + 1;
+                        state.consumed = '';
+                        state.output = '';
+                        tokens.pop();
+                        prev = bos;
+                        continue;
+                    }
+                    push({
+                        type: 'slash',
+                        value,
+                        output: SLASH_LITERAL
+                    });
+                    continue;
+                }
+                if ('.' === value) {
+                    if (state.braces > 0 && 'dot' === prev.type) {
+                        if ('.' === prev.value) prev.output = DOT_LITERAL;
+                        const brace = braces[braces.length - 1];
+                        prev.type = 'dots';
+                        prev.output += value;
+                        prev.value += value;
+                        brace.dots = true;
+                        continue;
+                    }
+                    if (state.braces + state.parens === 0 && 'bos' !== prev.type && 'slash' !== prev.type) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: DOT_LITERAL
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value,
+                        output: DOT_LITERAL
+                    });
+                    continue;
+                }
+                if ('?' === value) {
+                    const isGroup = prev && '(' === prev.value;
+                    if (!isGroup && true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('qmark', value);
+                        continue;
+                    }
+                    if (prev && 'paren' === prev.type) {
+                        const next = peek();
+                        let output = value;
+                        if ('(' === prev.value && !/[!=<:]/.test(next) || '<' === next && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+                        push({
+                            type: 'text',
+                            value,
+                            output
+                        });
+                        continue;
+                    }
+                    if (true !== opts.dot && ('slash' === prev.type || 'bos' === prev.type)) {
+                        push({
+                            type: 'qmark',
+                            value,
+                            output: QMARK_NO_DOT
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'qmark',
+                        value,
+                        output: QMARK
+                    });
+                    continue;
+                }
+                if ('!' === value) {
+                    if (true !== opts.noextglob && '(' === peek()) {
+                        if ('?' !== peek(2) || !/[!=<:]/.test(peek(3))) {
+                            extglobOpen('negate', value);
+                            continue;
+                        }
+                    }
+                    if (true !== opts.nonegate && 0 === state.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ('+' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('plus', value);
+                        continue;
+                    }
+                    if (prev && '(' === prev.value || false === opts.regex) {
+                        push({
+                            type: 'plus',
+                            value,
+                            output: PLUS_LITERAL
+                        });
+                        continue;
+                    }
+                    if (prev && ('bracket' === prev.type || 'paren' === prev.type || 'brace' === prev.type) || state.parens > 0) {
+                        push({
+                            type: 'plus',
+                            value
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'plus',
+                        value: PLUS_LITERAL
+                    });
+                    continue;
+                }
+                if ('@' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: true,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('*' !== value) {
+                    if ('$' === value || '^' === value) value = `\\${value}`;
+                    const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+                    if (match) {
+                        value += match[0];
+                        state.index += match[0].length;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (prev && ('globstar' === prev.type || true === prev.star)) {
+                    prev.type = 'star';
+                    prev.star = true;
+                    prev.value += value;
+                    prev.output = star;
+                    state.backtrack = true;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                let rest = remaining();
+                if (true !== opts.noextglob && /^\([^?]/.test(rest)) {
+                    extglobOpen('star', value);
+                    continue;
+                }
+                if ('star' === prev.type) {
+                    if (true === opts.noglobstar) {
+                        consume(value);
+                        continue;
+                    }
+                    const prior = prev.prev;
+                    const before = prior.prev;
+                    const isStart = 'slash' === prior.type || 'bos' === prior.type;
+                    const afterStar = before && ('star' === before.type || 'globstar' === before.type);
+                    if (true === opts.bash && (!isStart || rest[0] && '/' !== rest[0])) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    const isBrace = state.braces > 0 && ('comma' === prior.type || 'brace' === prior.type);
+                    const isExtglob = extglobs.length && ('pipe' === prior.type || 'paren' === prior.type);
+                    if (!isStart && 'paren' !== prior.type && !isBrace && !isExtglob) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    while('/**' === rest.slice(0, 3)){
+                        const after = input[state.index + 4];
+                        if (after && '/' !== after) break;
+                        rest = rest.slice(3);
+                        consume('/**', 3);
+                    }
+                    if ('bos' === prior.type && eos()) {
+                        prev.type = 'globstar';
+                        prev.value += value;
+                        prev.output = globstar(opts);
+                        state.output = prev.output;
+                        state.globstar = true;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && !afterStar && eos()) {
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                        prior.output = `(?:${prior.output}`;
+                        prev.type = 'globstar';
+                        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+                        prev.value += value;
+                        state.globstar = true;
+                        state.output += prior.output + prev.output;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && '/' === rest[0]) {
+                        const end = void 0 !== rest[1] ? '|$' : '';
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                        prior.output = `(?:${prior.output}`;
+                        prev.type = 'globstar';
+                        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+                        prev.value += value;
+                        state.output += prior.output + prev.output;
+                        state.globstar = true;
+                        consume(value + advance());
+                        push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    if ('bos' === prior.type && '/' === rest[0]) {
+                        prev.type = 'globstar';
+                        prev.value += value;
+                        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+                        state.output = prev.output;
+                        state.globstar = true;
+                        consume(value + advance());
+                        push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    state.output = state.output.slice(0, -prev.output.length);
+                    prev.type = 'globstar';
+                    prev.output = globstar(opts);
+                    prev.value += value;
+                    state.output += prev.output;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                const token = {
+                    type: 'star',
+                    value,
+                    output: star
+                };
+                if (true === opts.bash) {
+                    token.output = '.*?';
+                    if ('bos' === prev.type || 'slash' === prev.type) token.output = nodot + token.output;
+                    push(token);
+                    continue;
+                }
+                if (prev && ('bracket' === prev.type || 'paren' === prev.type) && true === opts.regex) {
+                    token.output = value;
+                    push(token);
+                    continue;
+                }
+                if (state.index === state.start || 'slash' === prev.type || 'dot' === prev.type) {
+                    if ('dot' === prev.type) {
+                        state.output += NO_DOT_SLASH;
+                        prev.output += NO_DOT_SLASH;
+                    } else if (true === opts.dot) {
+                        state.output += NO_DOTS_SLASH;
+                        prev.output += NO_DOTS_SLASH;
+                    } else {
+                        state.output += nodot;
+                        prev.output += nodot;
+                    }
+                    if ('*' !== peek()) {
+                        state.output += ONE_CHAR;
+                        prev.output += ONE_CHAR;
+                    }
+                }
+                push(token);
+            }
+            while(state.brackets > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                state.output = utils.escapeLast(state.output, '[');
+                decrement('brackets');
+            }
+            while(state.parens > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ')'));
+                state.output = utils.escapeLast(state.output, '(');
+                decrement('parens');
+            }
+            while(state.braces > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', '}'));
+                state.output = utils.escapeLast(state.output, '{');
+                decrement('braces');
+            }
+            if (true !== opts.strictSlashes && ('star' === prev.type || 'bracket' === prev.type)) push({
+                type: 'maybe_slash',
+                value: '',
+                output: `${SLASH_LITERAL}?`
+            });
+            if (true === state.backtrack) {
+                state.output = '';
+                for (const token of state.tokens){
+                    state.output += null != token.output ? token.output : token.value;
+                    if (token.suffix) state.output += token.suffix;
+                }
+            }
+            return state;
+        };
+        parse.fastpaths = (input, options)=>{
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            const len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            input = REPLACEMENTS[input] || input;
+            const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
+            const nodot = opts.dot ? NO_DOTS : NO_DOT;
+            const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+            const capture = opts.capture ? '' : '?:';
+            const state = {
+                negated: false,
+                prefix: ''
+            };
+            let star = true === opts.bash ? '.*?' : STAR;
+            if (opts.capture) star = `(${star})`;
+            const globstar = (opts)=>{
+                if (true === opts.noglobstar) return star;
+                return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            };
+            const create = (str)=>{
+                switch(str){
+                    case '*':
+                        return `${nodot}${ONE_CHAR}${star}`;
+                    case '.*':
+                        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*.*':
+                        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*/*':
+                        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+                    case '**':
+                        return nodot + globstar(opts);
+                    case '**/*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+                    case '**/*.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '**/.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    default:
+                        {
+                            const match = /^(.*?)\.(\w+)$/.exec(str);
+                            if (!match) return;
+                            const source = create(match[1]);
+                            if (!source) return;
+                            return source + DOT_LITERAL + match[2];
+                        }
+                }
+            };
+            const output = utils.removePrefix(input, state);
+            let source = create(output);
+            if (source && true !== opts.strictSlashes) source += `${SLASH_LITERAL}?`;
+            return source;
+        };
+        module.exports = parse;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/picomatch.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const scan = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/scan.js");
+        const parse = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/parse.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        const constants = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        const isObject = (val)=>val && 'object' == typeof val && !Array.isArray(val);
+        const picomatch = (glob, options, returnState = false)=>{
+            if (Array.isArray(glob)) {
+                const fns = glob.map((input)=>picomatch(input, options, returnState));
+                const arrayMatcher = (str)=>{
+                    for (const isMatch of fns){
+                        const state = isMatch(str);
+                        if (state) return state;
+                    }
+                    return false;
+                };
+                return arrayMatcher;
+            }
+            const isState = isObject(glob) && glob.tokens && glob.input;
+            if ('' === glob || 'string' != typeof glob && !isState) throw new TypeError('Expected pattern to be a non-empty string');
+            const opts = options || {};
+            const posix = opts.windows;
+            const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+            const state = regex.state;
+            delete regex.state;
+            let isIgnored = ()=>false;
+            if (opts.ignore) {
+                const ignoreOpts = {
+                    ...options,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+            }
+            const matcher = (input, returnObject = false)=>{
+                const { isMatch, match, output } = picomatch.test(input, regex, options, {
+                    glob,
+                    posix
+                });
+                const result = {
+                    glob,
+                    state,
+                    regex,
+                    posix,
+                    input,
+                    output,
+                    match,
+                    isMatch
+                };
+                if ('function' == typeof opts.onResult) opts.onResult(result);
+                if (false === isMatch) {
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if (isIgnored(input)) {
+                    if ('function' == typeof opts.onIgnore) opts.onIgnore(result);
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if ('function' == typeof opts.onMatch) opts.onMatch(result);
+                return returnObject ? result : true;
+            };
+            if (returnState) matcher.state = state;
+            return matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected input to be a string');
+            if ('' === input) return {
+                isMatch: false,
+                output: ''
+            };
+            const opts = options || {};
+            const format = opts.format || (posix ? utils.toPosixSlashes : null);
+            let match = input === glob;
+            let output = match && format ? format(input) : input;
+            if (false === match) {
+                output = format ? format(input) : input;
+                match = output === glob;
+            }
+            if (false === match || true === opts.capture) match = true === opts.matchBase || true === opts.basename ? picomatch.matchBase(input, regex, options, posix) : regex.exec(output);
+            return {
+                isMatch: Boolean(match),
+                match,
+                output
+            };
+        };
+        picomatch.matchBase = (input, glob, options)=>{
+            const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+            return regex.test(utils.basename(input));
+        };
+        picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        picomatch.parse = (pattern, options)=>{
+            if (Array.isArray(pattern)) return pattern.map((p)=>picomatch.parse(p, options));
+            return parse(pattern, {
+                ...options,
+                fastpaths: false
+            });
+        };
+        picomatch.scan = (input, options)=>scan(input, options);
+        picomatch.compileRe = (state, options, returnOutput = false, returnState = false)=>{
+            if (true === returnOutput) return state.output;
+            const opts = options || {};
+            const prepend = opts.contains ? '' : '^';
+            const append = opts.contains ? '' : '$';
+            let source = `${prepend}(?:${state.output})${append}`;
+            if (state && true === state.negated) source = `^(?!${source}).*$`;
+            const regex = picomatch.toRegex(source, options);
+            if (true === returnState) regex.state = state;
+            return regex;
+        };
+        picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false)=>{
+            if (!input || 'string' != typeof input) throw new TypeError('Expected a non-empty string');
+            let parsed = {
+                negated: false,
+                fastpaths: true
+            };
+            if (false !== options.fastpaths && ('.' === input[0] || '*' === input[0])) parsed.output = parse.fastpaths(input, options);
+            if (!parsed.output) parsed = parse(input, options);
+            return picomatch.compileRe(parsed, options, returnOutput, returnState);
+        };
+        picomatch.toRegex = (source, options)=>{
+            try {
+                const opts = options || {};
+                return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+            } catch (err) {
+                if (options && true === options.debug) throw err;
+                return /$^/;
+            }
+        };
+        picomatch.constants = constants;
+        module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/scan.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        const isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        const depth = (token)=>{
+            if (true !== token.isPrefix) token.depth = token.isGlobstar ? 1 / 0 : 1;
+        };
+        const scan = (input, options)=>{
+            const opts = options || {};
+            const length = input.length - 1;
+            const scanToEnd = true === opts.parts || true === opts.scanToEnd;
+            const slashes = [];
+            const tokens = [];
+            const parts = [];
+            let str = input;
+            let index = -1;
+            let start = 0;
+            let lastIndex = 0;
+            let isBrace = false;
+            let isBracket = false;
+            let isGlob = false;
+            let isExtglob = false;
+            let isGlobstar = false;
+            let braceEscaped = false;
+            let backslashes = false;
+            let negated = false;
+            let negatedExtglob = false;
+            let finished = false;
+            let braces = 0;
+            let prev;
+            let code;
+            let token = {
+                value: '',
+                depth: 0,
+                isGlob: false
+            };
+            const eos = ()=>index >= length;
+            const peek = ()=>str.charCodeAt(index + 1);
+            const advance = ()=>{
+                prev = code;
+                return str.charCodeAt(++index);
+            };
+            while(index < length){
+                code = advance();
+                let next;
+                if (code === CHAR_BACKWARD_SLASH) {
+                    backslashes = token.backslashes = true;
+                    code = advance();
+                    if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
+                    continue;
+                }
+                if (true === braceEscaped || code === CHAR_LEFT_CURLY_BRACE) {
+                    braces++;
+                    while(true !== eos() && (code = advance())){
+                        if (code === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (code === CHAR_LEFT_CURLY_BRACE) {
+                            braces++;
+                            continue;
+                        }
+                        if (true !== braceEscaped && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (true !== braceEscaped && code === CHAR_COMMA) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (code === CHAR_RIGHT_CURLY_BRACE) {
+                            braces--;
+                            if (0 === braces) {
+                                braceEscaped = false;
+                                isBrace = token.isBrace = true;
+                                finished = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_FORWARD_SLASH) {
+                    slashes.push(index);
+                    tokens.push(token);
+                    token = {
+                        value: '',
+                        depth: 0,
+                        isGlob: false
+                    };
+                    if (true === finished) continue;
+                    if (prev === CHAR_DOT && index === start + 1) {
+                        start += 2;
+                        continue;
+                    }
+                    lastIndex = index + 1;
+                    continue;
+                }
+                if (true !== opts.noext) {
+                    const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+                    if (true === isExtglobChar && peek() === CHAR_LEFT_PARENTHESES) {
+                        isGlob = token.isGlob = true;
+                        isExtglob = token.isExtglob = true;
+                        finished = true;
+                        if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+                        if (true === scanToEnd) {
+                            while(true !== eos() && (code = advance())){
+                                if (code === CHAR_BACKWARD_SLASH) {
+                                    backslashes = token.backslashes = true;
+                                    code = advance();
+                                    continue;
+                                }
+                                if (code === CHAR_RIGHT_PARENTHESES) {
+                                    isGlob = token.isGlob = true;
+                                    finished = true;
+                                    break;
+                                }
+                            }
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                if (code === CHAR_ASTERISK) {
+                    if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_QUESTION_MARK) {
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_LEFT_SQUARE_BRACKET) {
+                    while(true !== eos() && (next = advance())){
+                        if (next === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            isBracket = token.isBracket = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            break;
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (true !== opts.nonegate && code === CHAR_EXCLAMATION_MARK && index === start) {
+                    negated = token.negated = true;
+                    start++;
+                    continue;
+                }
+                if (true !== opts.noparen && code === CHAR_LEFT_PARENTHESES) {
+                    isGlob = token.isGlob = true;
+                    if (true === scanToEnd) {
+                        while(true !== eos() && (code = advance())){
+                            if (code === CHAR_LEFT_PARENTHESES) {
+                                backslashes = token.backslashes = true;
+                                code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                finished = true;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (true === isGlob) {
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+            }
+            if (true === opts.noext) {
+                isExtglob = false;
+                isGlob = false;
+            }
+            let base = str;
+            let prefix = '';
+            let glob = '';
+            if (start > 0) {
+                prefix = str.slice(0, start);
+                str = str.slice(start);
+                lastIndex -= start;
+            }
+            if (base && true === isGlob && lastIndex > 0) {
+                base = str.slice(0, lastIndex);
+                glob = str.slice(lastIndex);
+            } else if (true === isGlob) {
+                base = '';
+                glob = str;
+            } else base = str;
+            if (base && '' !== base && '/' !== base && base !== str) {
+                if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
+            }
+            if (true === opts.unescape) {
+                if (glob) glob = utils.removeBackslashes(glob);
+                if (base && true === backslashes) base = utils.removeBackslashes(base);
+            }
+            const state = {
+                prefix,
+                input,
+                start,
+                base,
+                glob,
+                isBrace,
+                isBracket,
+                isGlob,
+                isExtglob,
+                isGlobstar,
+                negated,
+                negatedExtglob
+            };
+            if (true === opts.tokens) {
+                state.maxDepth = 0;
+                if (!isPathSeparator(code)) tokens.push(token);
+                state.tokens = tokens;
+            }
+            if (true === opts.parts || true === opts.tokens) {
+                let prevIndex;
+                for(let idx = 0; idx < slashes.length; idx++){
+                    const n = prevIndex ? prevIndex + 1 : start;
+                    const i = slashes[idx];
+                    const value = input.slice(n, i);
+                    if (opts.tokens) {
+                        if (0 === idx && 0 !== start) {
+                            tokens[idx].isPrefix = true;
+                            tokens[idx].value = prefix;
+                        } else tokens[idx].value = value;
+                        depth(tokens[idx]);
+                        state.maxDepth += tokens[idx].depth;
+                    }
+                    if (0 !== idx || '' !== value) parts.push(value);
+                    prevIndex = i;
+                }
+                if (prevIndex && prevIndex + 1 < input.length) {
+                    const value = input.slice(prevIndex + 1);
+                    parts.push(value);
+                    if (opts.tokens) {
+                        tokens[tokens.length - 1].value = value;
+                        depth(tokens[tokens.length - 1]);
+                        state.maxDepth += tokens[tokens.length - 1].depth;
+                    }
+                }
+                state.slashes = slashes;
+                state.parts = parts;
+            }
+            return state;
+        };
+        module.exports = scan;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        exports.isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        exports.hasRegexChars = (str)=>REGEX_SPECIAL_CHARS.test(str);
+        exports.isRegexChar = (str)=>1 === str.length && exports.hasRegexChars(str);
+        exports.escapeRegex = (str)=>str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+        exports.toPosixSlashes = (str)=>str.replace(REGEX_BACKSLASH, '/');
+        exports.isWindows = ()=>{
+            if ('undefined' != typeof navigator && navigator.platform) {
+                const platform = navigator.platform.toLowerCase();
+                return 'win32' === platform || 'windows' === platform;
+            }
+            if ('undefined' != typeof process && process.platform) return 'win32' === process.platform;
+            return false;
+        };
+        exports.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match);
+        exports.escapeLast = (input, char, lastIdx)=>{
+            const idx = input.lastIndexOf(char, lastIdx);
+            if (-1 === idx) return input;
+            if ('\\' === input[idx - 1]) return exports.escapeLast(input, char, idx - 1);
+            return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        };
+        exports.removePrefix = (input, state = {})=>{
+            let output = input;
+            if (output.startsWith('./')) {
+                output = output.slice(2);
+                state.prefix = './';
+            }
+            return output;
+        };
+        exports.wrapOutput = (input, state = {}, options = {})=>{
+            const prepend = options.contains ? '' : '^';
+            const append = options.contains ? '' : '$';
+            let output = `${prepend}(?:${input})${append}`;
+            if (true === state.negated) output = `(?:^(?!${output}).*$)`;
+            return output;
+        };
+        exports.basename = (path, { windows } = {})=>{
+            const segs = path.split(windows ? /[\\/]/ : '/');
+            const last = segs[segs.length - 1];
+            if ('' === last) return segs[segs.length - 2];
+            return last;
+        };
+    },
+    "./src/config.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            ME: ()=>loadConfig,
+            hY: ()=>withDefaultConfig
+        });
+        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__.Io.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);
+                if (node_fs__WEBPACK_IMPORTED_MODULE_0__["default"].existsSync(customConfigPath)) return customConfigPath;
+                _utils__WEBPACK_IMPORTED_MODULE_3__.kg.warn(`Cannot find config file: ${_utils__WEBPACK_IMPORTED_MODULE_3__.$_.dim(customConfigPath)}`);
+                _utils__WEBPACK_IMPORTED_MODULE_3__.kg.log('');
+            }
+            const configFilePath = findConfig((0, pathe__WEBPACK_IMPORTED_MODULE_2__.join)(root, _utils__WEBPACK_IMPORTED_MODULE_3__.F7));
+            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__.kg.debug('no 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),
+                path: configFilePath,
+                envMode,
+                loader: configLoader
+            });
+            return {
+                content: content,
+                filePath: configFilePath
+            };
+        }
+        const mergeRstestConfig = (...configs)=>(0, _rsbuild_core__WEBPACK_IMPORTED_MODULE_1__.mergeRsbuildConfig)(...configs);
+        const createDefaultConfig = ()=>({
+                root: process.cwd(),
+                name: 'rstest',
+                include: [
+                    '**/*.{test,spec}.?(c|m)[jt]s?(x)'
+                ],
+                exclude: [
+                    '**/node_modules/**',
+                    '**/dist/**'
+                ],
+                includeSource: [],
+                pool: {
+                    type: 'forks'
+                },
+                isolate: true,
+                globals: false,
+                passWithNoTests: false,
+                update: false,
+                testTimeout: 5000,
+                testEnvironment: 'node',
+                retry: 0,
+                reporters: [
+                    'default'
+                ],
+                clearMocks: false,
+                resetMocks: false,
+                restoreMocks: false,
+                slowTestThreshold: 300,
+                unstubGlobals: false,
+                unstubEnvs: false,
+                maxConcurrency: 5,
+                printConsoleTrace: false,
+                disableConsoleIntercept: false
+            });
+        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__.f1
+            ]);
+            merged.reporters = config.reporters ?? merged.reporters;
+            merged.pool = 'string' == typeof config.pool ? {
+                type: config.pool
+            } : merged.pool;
+            return merged;
+        };
+    },
+    "./src/utils/constants.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            F7: ()=>DEFAULT_CONFIG_NAME,
+            Io: ()=>DEFAULT_CONFIG_EXTENSIONS,
+            Nk: ()=>TEMP_RSTEST_OUTPUT_DIR,
+            Qd: ()=>TEST_DELIMITER,
+            f1: ()=>TEMP_RSTEST_OUTPUT_DIR_GLOB
+        });
+        const DEFAULT_CONFIG_NAME = 'rstest.config';
+        const TEST_DELIMITER = '>';
+        const TEMP_RSTEST_OUTPUT_DIR = 'dist/.rstest-temp';
+        const TEMP_RSTEST_OUTPUT_DIR_GLOB = '**/dist/.rstest-temp';
+        const DEFAULT_CONFIG_EXTENSIONS = [
+            '.js',
+            '.ts',
+            '.mjs',
+            '.mts',
+            '.cjs',
+            '.cts'
+        ];
+    },
+    "./src/utils/helper.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            $_: ()=>picocolors__WEBPACK_IMPORTED_MODULE_2___default.a,
+            AS: ()=>prettyTime,
+            H: ()=>parsePosix,
+            XQ: ()=>castArray,
+            Yz: ()=>getTaskNameWithPrefix,
+            Z: ()=>formatError,
+            ZY: ()=>getAbsolutePath,
+            v8: ()=>serializableConfig
+        });
+        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 _constants__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/utils/constants.ts");
+        function getAbsolutePath(base, filepath) {
+            return (0, pathe__WEBPACK_IMPORTED_MODULE_0__.isAbsolute)(filepath) ? filepath : (0, pathe__WEBPACK_IMPORTED_MODULE_0__.join)(base, filepath);
+        }
+        const parsePosix = (filePath)=>{
+            const { dir, base } = (0, pathe__WEBPACK_IMPORTED_MODULE_0__.parse)(filePath);
+            return {
+                dir: dir.split(pathe__WEBPACK_IMPORTED_MODULE_0__.sep).join('/'),
+                base
+            };
+        };
+        const castArray = (arr)=>{
+            if (void 0 === arr) return [];
+            return Array.isArray(arr) ? arr : [
+                arr
+            ];
+        };
+        const isPlainObject = (obj)=>null !== obj && 'object' == typeof obj && Object.getPrototypeOf(obj) === Object.prototype;
+        function formatError(error) {
+            if ('string' == typeof error || error instanceof Error) return error;
+            if (isPlainObject(error) && error.message) {
+                const e = new Error(error.name || 'unknown error');
+                e.message = error.message;
+                e.stack = error.stack;
+                return e;
+            }
+            return String(error);
+        }
+        const prettyTime = (milliseconds, shouldFormat = true)=>{
+            const format = (time)=>shouldFormat ? picocolors__WEBPACK_IMPORTED_MODULE_2___default().bold(time) : time;
+            const indent = shouldFormat ? ' ' : '';
+            if (milliseconds < 1000) return `${Math.round(milliseconds)}${indent}ms`;
+            const seconds = milliseconds / 1000;
+            if (seconds < 10) {
+                const digits = seconds >= 0.01 ? 2 : 3;
+                return `${format(seconds.toFixed(digits))}${indent}s`;
+            }
+            if (seconds < 60) return `${format(seconds.toFixed(1))}${indent}s`;
+            const minutes = seconds / 60;
+            return `${format(minutes.toFixed(2))}${indent}m`;
+        };
+        const getTaskNames = (test)=>(test.parentNames || []).concat(test.name).filter(Boolean);
+        const getTaskNameWithPrefix = (test, delimiter = _constants__WEBPACK_IMPORTED_MODULE_1__.Qd)=>getTaskNames(test).join(` ${delimiter} `);
+        const REGEXP_FLAG_PREFIX = 'RSTEST_REGEXP:';
+        const wrapRegex = (value)=>`${REGEXP_FLAG_PREFIX}${value.toString()}`;
+        const serializableConfig = (normalizedConfig)=>{
+            const { testNamePattern } = normalizedConfig;
+            return {
+                ...normalizedConfig,
+                testNamePattern: testNamePattern && 'string' != typeof testNamePattern ? wrapRegex(testNamePattern) : testNamePattern
+            };
+        };
+    },
+    "./src/utils/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            F7: ()=>constants.F7,
+            GL: ()=>getTestEntries,
+            aj: ()=>prettyTestPath,
+            aA: ()=>getSetupFiles,
+            kg: ()=>logger.k,
+            Io: ()=>constants.Io,
+            Ps: ()=>formatTestPath,
+            XQ: ()=>helper.XQ,
+            $_: ()=>helper.$_,
+            Nk: ()=>constants.Nk,
+            Yz: ()=>helper.Yz,
+            L1: ()=>logger.L,
+            v8: ()=>helper.v8,
+            Qd: ()=>constants.Qd,
+            f1: ()=>constants.f1,
+            AS: ()=>helper.AS
+        });
+        var helper = __webpack_require__("./src/utils/helper.ts");
+        var logger = __webpack_require__("./src/utils/logger.ts");
+        var promises_ = __webpack_require__("node:fs/promises");
+        var external_pathe_ = __webpack_require__("pathe");
+        var dist = __webpack_require__("../../node_modules/.pnpm/tinyglobby@0.2.14/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;
+            return testFiles.filter((t)=>{
+                const testFile = external_pathe_["default"].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);
+                    return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
+                });
+            });
+        };
+        const hasInSourceTestCode = (code)=>code.includes('import.meta.rstest');
+        const getTestEntries = async ({ include, exclude, root, fileFilters, includeSource })=>{
+            const testFiles = await (0, dist.zA)(include, {
+                cwd: root,
+                absolute: true,
+                ignore: exclude,
+                dot: true,
+                expandDirectories: false
+            });
+            if (includeSource?.length) {
+                const sourceFiles = await (0, dist.zA)(includeSource, {
+                    cwd: root,
+                    absolute: true,
+                    ignore: exclude,
+                    dot: true,
+                    expandDirectories: false
+                });
+                await Promise.all(sourceFiles.map(async (file)=>{
+                    try {
+                        const code = await promises_["default"].readFile(file, 'utf-8');
+                        if (hasInSourceTestCode(code)) testFiles.push(file);
+                    } catch  {
+                        return;
+                    }
+                }));
+            }
+            return Object.fromEntries(filterFiles(testFiles, fileFilters, root).map((entry)=>{
+                const name = external_pathe_["default"].relative(root, entry);
+                return [
+                    name,
+                    entry
+                ];
+            }));
+        };
+        const getSetupFiles = (setups, rootPath)=>Object.fromEntries((0, helper.XQ)(setups).map((setupFile)=>{
+                const setupFilePath = (0, helper.ZY)(rootPath, setupFile);
+                const name = external_pathe_["default"].relative(rootPath, setupFilePath);
+                return [
+                    name,
+                    setupFilePath
+                ];
+            }));
+        const prettyTestPath = (testPath)=>{
+            const { dir, base } = (0, helper.H)(testPath);
+            return `${'.' !== dir ? helper.$_.gray(`${dir}/`) : ''}${helper.$_.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);
+            return prettyTestPath(testPath);
+        };
+        var constants = __webpack_require__("./src/utils/constants.ts");
+    },
+    "./src/utils/logger.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            L: ()=>isDebug,
+            k: ()=>logger
+        });
+        var external_os_ = __webpack_require__("os");
+        var external_tty_ = __webpack_require__("tty");
+        function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : external_process_default.argv) {
+            const prefix = flag.startsWith("-") ? "" : 1 === flag.length ? "-" : "--";
+            const position = argv.indexOf(prefix + flag);
+            const terminatorPosition = argv.indexOf("--");
+            return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
+        }
+        var { env } = external_process_default;
+        var flagForceColor;
+        if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+        else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+        function envForceColor() {
+            if ("FORCE_COLOR" in env) {
+                if ("true" === env.FORCE_COLOR) return 1;
+                if ("false" === env.FORCE_COLOR) return 0;
+                return 0 === env.FORCE_COLOR.length ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+            }
+        }
+        function translateLevel(level) {
+            if (0 === level) return false;
+            return {
+                level,
+                hasBasic: true,
+                has256: level >= 2,
+                has16m: level >= 3
+            };
+        }
+        function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+            const noFlagForceColor = envForceColor();
+            if (void 0 !== noFlagForceColor) flagForceColor = noFlagForceColor;
+            const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+            if (0 === forceColor) return 0;
+            if (sniffFlags) {
+                if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+                if (hasFlag("color=256")) return 2;
+            }
+            if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+            if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
+            const min = forceColor || 0;
+            if ("dumb" === env.TERM) return min;
+            if ("win32" === external_process_default.platform) {
+                const osRelease = external_os_["default"].release().split(".");
+                if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+                return 1;
+            }
+            if ("CI" in env) {
+                if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) return 3;
+                if ([
+                    "TRAVIS",
+                    "CIRCLECI",
+                    "APPVEYOR",
+                    "GITLAB_CI",
+                    "BUILDKITE",
+                    "DRONE"
+                ].some((sign)=>sign in env) || "codeship" === env.CI_NAME) return 1;
+                return min;
+            }
+            if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+            if ("truecolor" === env.COLORTERM) return 3;
+            if ("xterm-kitty" === env.TERM) return 3;
+            if ("TERM_PROGRAM" in env) {
+                const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+                switch(env.TERM_PROGRAM){
+                    case "iTerm.app":
+                        return version >= 3 ? 3 : 2;
+                    case "Apple_Terminal":
+                        return 2;
+                }
+            }
+            if (/-256(color)?$/i.test(env.TERM)) return 2;
+            if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+            if ("COLORTERM" in env) return 1;
+            return min;
+        }
+        function createSupportsColor(stream, options = {}) {
+            const level = _supportsColor(stream, {
+                streamIsTTY: stream && stream.isTTY,
+                ...options
+            });
+            return translateLevel(level);
+        }
+        var supportsColor = {
+            stdout: createSupportsColor({
+                isTTY: external_tty_["default"].isatty(1)
+            }),
+            stderr: createSupportsColor({
+                isTTY: external_tty_["default"].isatty(2)
+            })
+        };
+        var supports_color_default = supportsColor;
+        var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
+        var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
+        var anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
+        var isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
+        var formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
+                let string = "" + input;
+                let index = string.indexOf(close, open.length);
+                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+            } : String;
+        var replaceClose = (string, close, replace, index)=>{
+            let start = string.substring(0, index) + replace;
+            let end = string.substring(index + close.length);
+            let nextIndex = end.indexOf(close);
+            return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+        };
+        var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
+        var red = formatter("\x1B[31m", "\x1B[39m");
+        var green = formatter("\x1B[32m", "\x1B[39m");
+        var yellow = formatter("\x1B[33m", "\x1B[39m");
+        var magenta = formatter("\x1B[35m", "\x1B[39m");
+        var cyan = formatter("\x1B[36m", "\x1B[39m");
+        var gray = formatter("\x1B[90m", "\x1B[39m");
+        var startColor = [
+            189,
+            255,
+            243
+        ];
+        var endColor = [
+            74,
+            194,
+            154
+        ];
+        var isWord = (char)=>!/[\s\n]/.test(char);
+        var gradient = (message)=>{
+            if (colorLevel < 3) return 2 === colorLevel ? bold(cyan(message)) : message;
+            let chars = [
+                ...message
+            ];
+            let steps = chars.filter(isWord).length;
+            let r = startColor[0];
+            let g = startColor[1];
+            let b = startColor[2];
+            let rStep = (endColor[0] - r) / steps;
+            let gStep = (endColor[1] - g) / steps;
+            let bStep = (endColor[2] - b) / steps;
+            let output = "";
+            for (let char of chars){
+                if (isWord(char)) {
+                    r += rStep;
+                    g += gStep;
+                    b += bStep;
+                }
+                output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1B[39m`;
+            }
+            return bold(output);
+        };
+        var LOG_LEVEL = {
+            error: 0,
+            warn: 1,
+            info: 2,
+            log: 3,
+            verbose: 4
+        };
+        var LOG_TYPES = {
+            error: {
+                label: "error",
+                level: "error",
+                color: red
+            },
+            warn: {
+                label: "warn",
+                level: "warn",
+                color: yellow
+            },
+            info: {
+                label: "info",
+                level: "info",
+                color: cyan
+            },
+            start: {
+                label: "start",
+                level: "info",
+                color: cyan
+            },
+            ready: {
+                label: "ready",
+                level: "info",
+                color: green
+            },
+            success: {
+                label: "success",
+                level: "info",
+                color: green
+            },
+            log: {
+                level: "log"
+            },
+            debug: {
+                label: "debug",
+                level: "verbose",
+                color: magenta
+            }
+        };
+        var createLogger = (options = {})=>{
+            let maxLevel = options.level || "log";
+            let log = (type, message, ...args)=>{
+                if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) return;
+                if (null == message) return console.log();
+                let logType = LOG_TYPES[type];
+                let label = "";
+                let text = "";
+                if ("label" in logType) {
+                    label = (logType.label || "").padEnd(7);
+                    label = bold(logType.color ? logType.color(label) : label);
+                }
+                if (message instanceof Error) if (message.stack) {
+                    let [name, ...rest] = message.stack.split("\n");
+                    if (name.startsWith("Error: ")) name = name.slice(7);
+                    text = `${name}
+${gray(rest.join("\n"))}`;
+                } else text = message.message;
+                else if ("error" === logType.level && "string" == typeof message) {
+                    let lines = message.split("\n");
+                    text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join("\n");
+                } else text = `${message}`;
+                console.log(label.length ? `${label} ${text}` : text, ...args);
+            };
+            let logger2 = {
+                greet: (message)=>log("log", gradient(message))
+            };
+            Object.keys(LOG_TYPES).forEach((key)=>{
+                logger2[key] = (...args)=>log(key, ...args);
+            });
+            Object.defineProperty(logger2, "level", {
+                get: ()=>maxLevel,
+                set (val) {
+                    maxLevel = val;
+                }
+            });
+            logger2.override = (customLogger)=>{
+                Object.assign(logger2, customLogger);
+            };
+            return logger2;
+        };
+        var logger = createLogger();
+        var helper = __webpack_require__("./src/utils/helper.ts");
+        const isDebug = ()=>{
+            if (!process.env.DEBUG) return false;
+            const values = process.env.DEBUG.toLocaleLowerCase().split(',');
+            return [
+                'rstest',
+                'rsbuild',
+                'builder',
+                '*'
+            ].some((key)=>values.includes(key));
+        };
+        if (isDebug()) logger.level = 'verbose';
+        function getTime() {
+            const now = new Date();
+            const hours = String(now.getHours()).padStart(2, '0');
+            const minutes = String(now.getMinutes()).padStart(2, '0');
+            const seconds = String(now.getSeconds()).padStart(2, '0');
+            return `${hours}:${minutes}:${seconds}`;
+        }
+        logger.override({
+            debug: (message, ...args)=>{
+                if ('verbose' !== logger.level) return;
+                const time = helper.$_.gray(`${getTime()}`);
+                console.log(`  ${helper.$_.magenta('rstest')} ${time} ${message}`, ...args);
+            }
+        });
+    },
+    "@rsbuild/core": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__rsbuild_core_1b356efc__;
+    },
+    "@vitest/snapshot/manager": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__vitest_snapshot_manager_ed2bcef6__;
+    },
+    birpc: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_birpc__;
+    },
+    fs: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_fs__;
+    },
+    "node:events": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__;
+    },
+    "node:fs": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__;
+    },
+    "node:fs/promises": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__;
+    },
+    "node:os": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__;
+    },
+    "node:path": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__;
+    },
+    "node:url": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__;
+    },
+    "node:util": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__;
+    },
+    "node:v8": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__;
+    },
+    os: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_os__;
+    },
+    path: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_path__;
+    },
+    pathe: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_pathe__;
+    },
+    "std-env": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_std_env_1c7b8267__;
+    },
+    tinypool: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_tinypool__;
+    },
+    tty: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_tty__;
+    },
+    "../../node_modules/.pnpm/tinyglobby@0.2.14/node_modules/tinyglobby/dist/index.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            zA: ()=>glob
+        });
+        var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("path");
+        var fdir__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/fdir@6.4.4_picomatch@4.0.2/node_modules/fdir/dist/index.js");
+        var picomatch__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/index.js");
+        const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+        function getPartialMatcher(patterns, options) {
+            const patternsCount = patterns.length;
+            const patternsParts = Array(patternsCount);
+            const regexes = Array(patternsCount);
+            for(let i = 0; i < patternsCount; i++){
+                const parts = splitPattern(patterns[i]);
+                patternsParts[i] = parts;
+                const partsCount = parts.length;
+                const partRegexes = Array(partsCount);
+                for(let j = 0; j < partsCount; j++)partRegexes[j] = picomatch__WEBPACK_IMPORTED_MODULE_2__.makeRe(parts[j], options);
+                regexes[i] = partRegexes;
+            }
+            return (input)=>{
+                const inputParts = input.split("/");
+                if (".." === inputParts[0] && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+                for(let i = 0; i < patterns.length; i++){
+                    const patternParts = patternsParts[i];
+                    const regex = regexes[i];
+                    const inputPatternCount = inputParts.length;
+                    const minParts = Math.min(inputPatternCount, patternParts.length);
+                    let j = 0;
+                    while(j < minParts){
+                        const part = patternParts[j];
+                        if (part.includes("/")) return true;
+                        const match = regex[j].test(inputParts[j]);
+                        if (!match) break;
+                        if ("**" === part) return true;
+                        j++;
+                    }
+                    if (j === inputPatternCount) return true;
+                }
+                return false;
+            };
+        }
+        const splitPatternOptions = {
+            parts: true
+        };
+        function splitPattern(path$1) {
+            var _result$parts;
+            const result = picomatch__WEBPACK_IMPORTED_MODULE_2__.scan(path$1, splitPatternOptions);
+            return (null == (_result$parts = result.parts) ? void 0 : _result$parts.length) ? result.parts : [
+                path$1
+            ];
+        }
+        const isWin = "win32" === process.platform;
+        const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+        const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+        const escapePosixPath = (path$1)=>path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+        const escapeWin32Path = (path$1)=>path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+        const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+        function isDynamicPattern(pattern, options) {
+            if ((null == options ? void 0 : options.caseSensitiveMatch) === false) return true;
+            const scan = picomatch__WEBPACK_IMPORTED_MODULE_2__.scan(pattern);
+            return scan.isGlob || scan.negated;
+        }
+        function log(...tasks) {
+            console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+        }
+        const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+        const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+        const BACKSLASHES = /\\/g;
+        function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+            let result = pattern;
+            if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+            if (!result.endsWith("*") && expandDirectories) result += "/**";
+            const escapedCwd = escapePath(cwd);
+            result = path__WEBPACK_IMPORTED_MODULE_0__["default"].isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? path__WEBPACK_IMPORTED_MODULE_0__.posix.relative(escapedCwd, result) : path__WEBPACK_IMPORTED_MODULE_0__.posix.normalize(result);
+            const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+            const parts = splitPattern(result);
+            if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
+                const n = (parentDirectoryMatch[0].length + 1) / 3;
+                let i = 0;
+                const cwdParts = escapedCwd.split("/");
+                while(i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]){
+                    result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+                    i++;
+                }
+                const potentialRoot = path__WEBPACK_IMPORTED_MODULE_0__.posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
+                if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+                    props.root = potentialRoot;
+                    props.depthOffset = -n + i;
+                }
+            }
+            if (!isIgnore && props.depthOffset >= 0) {
+                var _props$commonPath;
+                null != props.commonPath || (props.commonPath = parts);
+                const newCommonPath = [];
+                const length = Math.min(props.commonPath.length, parts.length);
+                for(let i = 0; i < length; i++){
+                    const part = parts[i];
+                    if ("**" === part && !parts[i + 1]) {
+                        newCommonPath.pop();
+                        break;
+                    }
+                    if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+                    newCommonPath.push(part);
+                }
+                props.depthOffset = newCommonPath.length;
+                props.commonPath = newCommonPath;
+                props.root = newCommonPath.length > 0 ? path__WEBPACK_IMPORTED_MODULE_0__["default"].posix.join(cwd, ...newCommonPath) : cwd;
+            }
+            return result;
+        }
+        function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
+            if ("string" == typeof patterns) patterns = [
+                patterns
+            ];
+            else if (!patterns) patterns = [
+                "**/*"
+            ];
+            if ("string" == typeof ignore) ignore = [
+                ignore
+            ];
+            const matchPatterns = [];
+            const ignorePatterns = [];
+            for (const pattern of ignore)if (pattern) {
+                if ("!" !== pattern[0] || "(" === pattern[1]) ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+            }
+            for (const pattern of patterns)if (pattern) {
+                if ("!" !== pattern[0] || "(" === pattern[1]) matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
+                else if ("!" !== pattern[1] || "(" === pattern[2]) ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+            }
+            return {
+                match: matchPatterns,
+                ignore: ignorePatterns
+            };
+        }
+        function getRelativePath(path$1, cwd, root) {
+            return path__WEBPACK_IMPORTED_MODULE_0__.posix.relative(cwd, `${root}/${path$1}`) || ".";
+        }
+        function processPath(path$1, cwd, root, isDirectory, absolute) {
+            const relativePath = absolute ? path$1.slice("/" === root ? 1 : root.length + 1) || "." : path$1;
+            if (root === cwd) return isDirectory && "." !== relativePath ? relativePath.slice(0, -1) : relativePath;
+            return getRelativePath(relativePath, cwd, root);
+        }
+        function formatPaths(paths, cwd, root) {
+            for(let i = paths.length - 1; i >= 0; i--){
+                const path$1 = paths[i];
+                paths[i] = getRelativePath(path$1, cwd, root) + (!path$1 || path$1.endsWith("/") ? "/" : "");
+            }
+            return paths;
+        }
+        function crawl(options, cwd, sync) {
+            if (process.env.TINYGLOBBY_DEBUG) options.debug = true;
+            if (options.debug) log("globbing with options:", options, "cwd:", cwd);
+            if (Array.isArray(options.patterns) && 0 === options.patterns.length) return sync ? [] : Promise.resolve([]);
+            const props = {
+                root: cwd,
+                commonPath: null,
+                depthOffset: 0
+            };
+            const processed = processPatterns(options, cwd, props);
+            const nocase = false === options.caseSensitiveMatch;
+            if (options.debug) log("internal processing patterns:", processed);
+            const matcher = picomatch__WEBPACK_IMPORTED_MODULE_2__(processed.match, {
+                dot: options.dot,
+                nocase,
+                ignore: processed.ignore
+            });
+            const ignore = picomatch__WEBPACK_IMPORTED_MODULE_2__(processed.ignore, {
+                dot: options.dot,
+                nocase
+            });
+            const partialMatcher = getPartialMatcher(processed.match, {
+                dot: options.dot,
+                nocase
+            });
+            const fdirOptions = {
+                filters: [
+                    options.debug ? (p, isDirectory)=>{
+                        const path$1 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+                        const matches = matcher(path$1);
+                        if (matches) log(`matched ${path$1}`);
+                        return matches;
+                    } : (p, isDirectory)=>matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))
+                ],
+                exclude: options.debug ? (_, p)=>{
+                    const relativePath = processPath(p, cwd, props.root, true, true);
+                    const skipped = "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+                    skipped ? log(`skipped ${p}`) : log(`crawling ${p}`);
+                    return skipped;
+                } : (_, p)=>{
+                    const relativePath = processPath(p, cwd, props.root, true, true);
+                    return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+                },
+                pathSeparator: "/",
+                relativePaths: true,
+                resolveSymlinks: true
+            };
+            if (void 0 !== options.deep) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+            if (options.absolute) {
+                fdirOptions.relativePaths = false;
+                fdirOptions.resolvePaths = true;
+                fdirOptions.includeBasePath = true;
+            }
+            if (false === options.followSymbolicLinks) {
+                fdirOptions.resolveSymlinks = false;
+                fdirOptions.excludeSymlinks = true;
+            }
+            if (options.onlyDirectories) {
+                fdirOptions.excludeFiles = true;
+                fdirOptions.includeDirs = true;
+            } else if (false === options.onlyFiles) fdirOptions.includeDirs = true;
+            props.root = props.root.replace(BACKSLASHES, "");
+            const root = props.root;
+            if (options.debug) log("internal properties:", props);
+            const api = new fdir__WEBPACK_IMPORTED_MODULE_1__.fdir(fdirOptions).crawl(root);
+            if (cwd === root || options.absolute) return sync ? api.sync() : api.withPromise();
+            return sync ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths)=>formatPaths(paths, cwd, root));
+        }
+        async function glob(patternsOrOptions, options) {
+            if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+            const opts = Array.isArray(patternsOrOptions) || "string" == typeof patternsOrOptions ? {
+                ...options,
+                patterns: patternsOrOptions
+            } : patternsOrOptions;
+            const cwd = opts.cwd ? path__WEBPACK_IMPORTED_MODULE_0__["default"].resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+            return crawl(opts, cwd, false);
+        }
+    }
+};
+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: {}
+    };
+    __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.f = {};
+    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
+            __webpack_require__.f[key](chunkId, promises);
+            return promises;
+        }, []));
+})();
+(()=>{
+    __webpack_require__.u = (chunkId)=>"" + chunkId + ".js";
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    var installedChunks = {
+        614: 0
+    };
+    var installChunk = (data)=>{
+        var __webpack_ids__ = data.__webpack_ids__;
+        var __webpack_modules__ = data.__webpack_modules__;
+        var __webpack_runtime__ = data.__webpack_runtime__;
+        var moduleId, chunkId, i = 0;
+        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
+        if (__webpack_runtime__) __webpack_runtime__(__webpack_require__);
+        for(; i < __webpack_ids__.length; i++){
+            chunkId = __webpack_ids__[i];
+            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
+            installedChunks[__webpack_ids__[i]] = 0;
+        }
+    };
+    __webpack_require__.f.j = function(chunkId, promises) {
+        var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
+        if (0 !== installedChunkData) if (installedChunkData) promises.push(installedChunkData[1]);
+        else {
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, (e)=>{
+                if (0 !== installedChunks[chunkId]) installedChunks[chunkId] = void 0;
+                throw e;
+            });
+            var promise = Promise.race([
+                promise,
+                new Promise((resolve)=>{
+                    installedChunkData = installedChunks[chunkId] = [
+                        resolve
+                    ];
+                })
+            ]);
+            promises.push(installedChunkData[1] = promise);
+        }
+    };
+})();
+var logger = __webpack_require__("./src/utils/logger.ts");
+function toArr(any) {
+    return null == any ? [] : Array.isArray(any) ? any : [
+        any
+    ];
+}
+function toVal(out, key, val, opts) {
+    var x, old = out[key], nxt = ~opts.string.indexOf(key) ? null == val || true === val ? '' : String(val) : 'boolean' == typeof val ? val : ~opts.boolean.indexOf(key) ? 'false' === val ? false : 'true' === val || (out._.push((x = +val, 0 * x === 0) ? x : val), !!val) : (x = +val, 0 * x === 0) ? x : val;
+    out[key] = null == old ? nxt : Array.isArray(old) ? old.concat(nxt) : [
+        old,
+        nxt
+    ];
+}
+function mri2(args, opts) {
+    args = args || [];
+    opts = opts || {};
+    var k, arr, arg, name, val, out = {
+        _: []
+    };
+    var i = 0, j = 0, idx = 0, len = args.length;
+    const alibi = void 0 !== opts.alias;
+    const strict = void 0 !== opts.unknown;
+    const defaults = void 0 !== opts.default;
+    opts.alias = opts.alias || {};
+    opts.string = toArr(opts.string);
+    opts.boolean = toArr(opts.boolean);
+    if (alibi) for(k in opts.alias){
+        arr = opts.alias[k] = toArr(opts.alias[k]);
+        for(i = 0; i < arr.length; i++)(opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+    }
+    for(i = opts.boolean.length; i-- > 0;){
+        arr = opts.alias[opts.boolean[i]] || [];
+        for(j = arr.length; j-- > 0;)opts.boolean.push(arr[j]);
+    }
+    for(i = opts.string.length; i-- > 0;){
+        arr = opts.alias[opts.string[i]] || [];
+        for(j = arr.length; j-- > 0;)opts.string.push(arr[j]);
+    }
+    if (defaults) for(k in opts.default){
+        name = typeof opts.default[k];
+        arr = opts.alias[k] = opts.alias[k] || [];
+        if (void 0 !== opts[name]) {
+            opts[name].push(k);
+            for(i = 0; i < arr.length; i++)opts[name].push(arr[i]);
+        }
+    }
+    const keys = strict ? Object.keys(opts.alias) : [];
+    for(i = 0; i < len; i++){
+        arg = args[i];
+        if ('--' === arg) {
+            out._ = out._.concat(args.slice(++i));
+            break;
+        }
+        for(j = 0; j < arg.length && 45 === arg.charCodeAt(j); j++);
+        if (0 === j) out._.push(arg);
+        else if ('no-' === arg.substring(j, j + 3)) {
+            name = arg.substring(j + 3);
+            if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
+            out[name] = false;
+        } else {
+            for(idx = j + 1; idx < arg.length && 61 !== arg.charCodeAt(idx); idx++);
+            name = arg.substring(j, idx);
+            val = arg.substring(++idx) || i + 1 === len || 45 === ('' + args[i + 1]).charCodeAt(0) || args[++i];
+            arr = 2 === j ? [
+                name
+            ] : name;
+            for(idx = 0; idx < arr.length; idx++){
+                name = arr[idx];
+                if (strict && !~keys.indexOf(name)) return opts.unknown('-'.repeat(j) + name);
+                toVal(out, name, idx + 1 < arr.length || val, opts);
+            }
+        }
+    }
+    if (defaults) {
+        for(k in opts.default)if (void 0 === out[k]) out[k] = opts.default[k];
+    }
+    if (alibi) for(k in out){
+        arr = opts.alias[k] || [];
+        while(arr.length > 0)out[arr.shift()] = out[k];
+    }
+    return out;
+}
+const removeBrackets = (v)=>v.replace(/[<[].+/, "").trim();
+const findAllBrackets = (v)=>{
+    const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+    const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+    const res = [];
+    const parse = (match)=>{
+        let variadic = false;
+        let value = match[1];
+        if (value.startsWith("...")) {
+            value = value.slice(3);
+            variadic = true;
+        }
+        return {
+            required: match[0].startsWith("<"),
+            value,
+            variadic
+        };
+    };
+    let angledMatch;
+    while(angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v))res.push(parse(angledMatch));
+    let squareMatch;
+    while(squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v))res.push(parse(squareMatch));
+    return res;
+};
+const getMriOptions = (options)=>{
+    const result = {
+        alias: {},
+        boolean: []
+    };
+    for (const [index, option] of options.entries()){
+        if (option.names.length > 1) result.alias[option.names[0]] = option.names.slice(1);
+        if (option.isBoolean) if (option.negated) {
+            const hasStringTypeOption = options.some((o, i)=>i !== index && o.names.some((name)=>option.names.includes(name)) && "boolean" == typeof o.required);
+            if (!hasStringTypeOption) result.boolean.push(option.names[0]);
+        } else result.boolean.push(option.names[0]);
+    }
+    return result;
+};
+const findLongest = (arr)=>arr.sort((a, b)=>a.length > b.length ? -1 : 1)[0];
+const padRight = (str, length)=>str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+const camelcase = (input)=>input.replace(/([a-z])-([a-z])/g, (_, p1, p2)=>p1 + p2.toUpperCase());
+const setDotProp = (obj, keys, val)=>{
+    let i = 0;
+    let length = keys.length;
+    let t = obj;
+    let x;
+    for(; i < length; ++i){
+        x = t[keys[i]];
+        t = t[keys[i]] = i === length - 1 ? val : null != x ? x : !~keys[i + 1].indexOf(".") && +keys[i + 1] > -1 ? [] : {};
+    }
+};
+const setByType = (obj, transforms)=>{
+    for (const key of Object.keys(transforms)){
+        const transform = transforms[key];
+        if (transform.shouldTransform) {
+            obj[key] = Array.prototype.concat.call([], obj[key]);
+            if ("function" == typeof transform.transformFunction) obj[key] = obj[key].map(transform.transformFunction);
+        }
+    }
+};
+const getFileName = (input)=>{
+    const m = /([^\\\/]+)$/.exec(input);
+    return m ? m[1] : "";
+};
+const camelcaseOptionName = (name)=>name.split(".").map((v, i)=>0 === i ? camelcase(v) : v).join(".");
+class CACError extends Error {
+    constructor(message){
+        super(message);
+        this.name = this.constructor.name;
+        if ("function" == typeof Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+        else this.stack = new Error(message).stack;
+    }
+}
+class Option {
+    constructor(rawName, description, config){
+        this.rawName = rawName;
+        this.description = description;
+        this.config = Object.assign({}, config);
+        rawName = rawName.replace(/\.\*/g, "");
+        this.negated = false;
+        this.names = removeBrackets(rawName).split(",").map((v)=>{
+            let name = v.trim().replace(/^-{1,2}/, "");
+            if (name.startsWith("no-")) {
+                this.negated = true;
+                name = name.replace(/^no-/, "");
+            }
+            return camelcaseOptionName(name);
+        }).sort((a, b)=>a.length > b.length ? 1 : -1);
+        this.name = this.names[this.names.length - 1];
+        if (this.negated && null == this.config.default) this.config.default = true;
+        if (rawName.includes("<")) this.required = true;
+        else if (rawName.includes("[")) this.required = false;
+        else this.isBoolean = true;
+    }
+}
+const processArgs = process.argv;
+const platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+class Command {
+    constructor(rawName, description, config = {}, cli){
+        this.rawName = rawName;
+        this.description = description;
+        this.config = config;
+        this.cli = cli;
+        this.options = [];
+        this.aliasNames = [];
+        this.name = removeBrackets(rawName);
+        this.args = findAllBrackets(rawName);
+        this.examples = [];
+    }
+    usage(text) {
+        this.usageText = text;
+        return this;
+    }
+    allowUnknownOptions() {
+        this.config.allowUnknownOptions = true;
+        return this;
+    }
+    ignoreOptionDefaultValue() {
+        this.config.ignoreOptionDefaultValue = true;
+        return this;
+    }
+    version(version, customFlags = "-v, --version") {
+        this.versionNumber = version;
+        this.option(customFlags, "Display version number");
+        return this;
+    }
+    example(example) {
+        this.examples.push(example);
+        return this;
+    }
+    option(rawName, description, config) {
+        const option = new Option(rawName, description, config);
+        this.options.push(option);
+        return this;
+    }
+    alias(name) {
+        this.aliasNames.push(name);
+        return this;
+    }
+    action(callback) {
+        this.commandAction = callback;
+        return this;
+    }
+    isMatched(name) {
+        return this.name === name || this.aliasNames.includes(name);
+    }
+    get isDefaultCommand() {
+        return "" === this.name || this.aliasNames.includes("!");
+    }
+    get isGlobalCommand() {
+        return this instanceof GlobalCommand;
+    }
+    hasOption(name) {
+        name = name.split(".")[0];
+        return this.options.find((option)=>option.names.includes(name));
+    }
+    outputHelp() {
+        const { name, commands } = this.cli;
+        const { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand;
+        let sections = [
+            {
+                body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+            }
+        ];
+        sections.push({
+            title: "Usage",
+            body: `  $ ${name} ${this.usageText || this.rawName}`
+        });
+        const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+        if (showCommands) {
+            const longestCommandName = findLongest(commands.map((command)=>command.rawName));
+            sections.push({
+                title: "Commands",
+                body: commands.map((command)=>`  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`).join("\n")
+            });
+            sections.push({
+                title: "For more info, run any command with the `--help` flag",
+                body: commands.map((command)=>`  $ ${name}${"" === command.name ? "" : ` ${command.name}`} --help`).join("\n")
+            });
+        }
+        let options = this.isGlobalCommand ? globalOptions : [
+            ...this.options,
+            ...globalOptions || []
+        ];
+        if (!this.isGlobalCommand && !this.isDefaultCommand) options = options.filter((option)=>"version" !== option.name);
+        if (options.length > 0) {
+            const longestOptionName = findLongest(options.map((option)=>option.rawName));
+            sections.push({
+                title: "Options",
+                body: options.map((option)=>`  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${void 0 === option.config.default ? "" : `(default: ${option.config.default})`}`).join("\n")
+            });
+        }
+        if (this.examples.length > 0) sections.push({
+            title: "Examples",
+            body: this.examples.map((example)=>{
+                if ("function" == typeof example) return example(name);
+                return example;
+            }).join("\n")
+        });
+        if (helpCallback) sections = helpCallback(sections) || sections;
+        console.log(sections.map((section)=>section.title ? `${section.title}:
+${section.body}` : section.body).join("\n\n"));
+    }
+    outputVersion() {
+        const { name } = this.cli;
+        const { versionNumber } = this.cli.globalCommand;
+        if (versionNumber) console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+    checkRequiredArgs() {
+        const minimalArgsCount = this.args.filter((arg)=>arg.required).length;
+        if (this.cli.args.length < minimalArgsCount) throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+    checkUnknownOptions() {
+        const { options, globalCommand } = this.cli;
+        if (!this.config.allowUnknownOptions) {
+            for (const name of Object.keys(options))if ("--" !== name && !this.hasOption(name) && !globalCommand.hasOption(name)) throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+    }
+    checkOptionValue() {
+        const { options: parsedOptions, globalCommand } = this.cli;
+        const options = [
+            ...globalCommand.options,
+            ...this.options
+        ];
+        for (const option of options){
+            const value = parsedOptions[option.name.split(".")[0]];
+            if (option.required) {
+                const hasNegated = options.some((o)=>o.negated && o.names.includes(option.name));
+                if (true === value || false === value && !hasNegated) throw new CACError(`option \`${option.rawName}\` value is missing`);
+            }
+        }
+    }
+}
+class GlobalCommand extends Command {
+    constructor(cli){
+        super("@@global@@", "", {}, cli);
+    }
+}
+var __assign = Object.assign;
+class CAC extends EventEmitter {
+    constructor(name = ""){
+        super();
+        this.name = name;
+        this.commands = [];
+        this.rawArgs = [];
+        this.args = [];
+        this.options = {};
+        this.globalCommand = new GlobalCommand(this);
+        this.globalCommand.usage("<command> [options]");
+    }
+    usage(text) {
+        this.globalCommand.usage(text);
+        return this;
+    }
+    command(rawName, description, config) {
+        const command = new Command(rawName, description || "", config, this);
+        command.globalCommand = this.globalCommand;
+        this.commands.push(command);
+        return command;
+    }
+    option(rawName, description, config) {
+        this.globalCommand.option(rawName, description, config);
+        return this;
+    }
+    help(callback) {
+        this.globalCommand.option("-h, --help", "Display this message");
+        this.globalCommand.helpCallback = callback;
+        this.showHelpOnExit = true;
+        return this;
+    }
+    version(version, customFlags = "-v, --version") {
+        this.globalCommand.version(version, customFlags);
+        this.showVersionOnExit = true;
+        return this;
+    }
+    example(example) {
+        this.globalCommand.example(example);
+        return this;
+    }
+    outputHelp() {
+        if (this.matchedCommand) this.matchedCommand.outputHelp();
+        else this.globalCommand.outputHelp();
+    }
+    outputVersion() {
+        this.globalCommand.outputVersion();
+    }
+    setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+        this.args = args;
+        this.options = options;
+        if (matchedCommand) this.matchedCommand = matchedCommand;
+        if (matchedCommandName) this.matchedCommandName = matchedCommandName;
+        return this;
+    }
+    unsetMatchedCommand() {
+        this.matchedCommand = void 0;
+        this.matchedCommandName = void 0;
+    }
+    parse(argv = processArgs, { run = true } = {}) {
+        this.rawArgs = argv;
+        if (!this.name) this.name = argv[1] ? getFileName(argv[1]) : "cli";
+        let shouldParse = true;
+        for (const command of this.commands){
+            const parsed = this.mri(argv.slice(2), command);
+            const commandName = parsed.args[0];
+            if (command.isMatched(commandName)) {
+                shouldParse = false;
+                const parsedInfo = __assign(__assign({}, parsed), {
+                    args: parsed.args.slice(1)
+                });
+                this.setParsedInfo(parsedInfo, command, commandName);
+                this.emit(`command:${commandName}`, command);
+            }
+        }
+        if (shouldParse) {
+            for (const command of this.commands)if ("" === command.name) {
+                shouldParse = false;
+                const parsed = this.mri(argv.slice(2), command);
+                this.setParsedInfo(parsed, command);
+                this.emit("command:!", command);
+            }
+        }
+        if (shouldParse) {
+            const parsed = this.mri(argv.slice(2));
+            this.setParsedInfo(parsed);
+        }
+        if (this.options.help && this.showHelpOnExit) {
+            this.outputHelp();
+            run = false;
+            this.unsetMatchedCommand();
+        }
+        if (this.options.version && this.showVersionOnExit && null == this.matchedCommandName) {
+            this.outputVersion();
+            run = false;
+            this.unsetMatchedCommand();
+        }
+        const parsedArgv = {
+            args: this.args,
+            options: this.options
+        };
+        if (run) this.runMatchedCommand();
+        if (!this.matchedCommand && this.args[0]) this.emit("command:*");
+        return parsedArgv;
+    }
+    mri(argv, command) {
+        const cliOptions = [
+            ...this.globalCommand.options,
+            ...command ? command.options : []
+        ];
+        const mriOptions = getMriOptions(cliOptions);
+        let argsAfterDoubleDashes = [];
+        const doubleDashesIndex = argv.indexOf("--");
+        if (doubleDashesIndex > -1) {
+            argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+            argv = argv.slice(0, doubleDashesIndex);
+        }
+        let parsed = mri2(argv, mriOptions);
+        parsed = Object.keys(parsed).reduce((res, name)=>__assign(__assign({}, res), {
+                [camelcaseOptionName(name)]: parsed[name]
+            }), {
+            _: []
+        });
+        const args = parsed._;
+        const options = {
+            "--": argsAfterDoubleDashes
+        };
+        const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+        let transforms = Object.create(null);
+        for (const cliOption of cliOptions){
+            if (!ignoreDefault && void 0 !== cliOption.config.default) for (const name of cliOption.names)options[name] = cliOption.config.default;
+            if (Array.isArray(cliOption.config.type)) {
+                if (void 0 === transforms[cliOption.name]) {
+                    transforms[cliOption.name] = Object.create(null);
+                    transforms[cliOption.name]["shouldTransform"] = true;
+                    transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+                }
+            }
+        }
+        for (const key of Object.keys(parsed))if ("_" !== key) {
+            const keys = key.split(".");
+            setDotProp(options, keys, parsed[key]);
+            setByType(options, transforms);
+        }
+        return {
+            args,
+            options
+        };
+    }
+    runMatchedCommand() {
+        const { args, options, matchedCommand: command } = this;
+        if (!command || !command.commandAction) return;
+        command.checkUnknownOptions();
+        command.checkOptionValue();
+        command.checkRequiredArgs();
+        const actionArgs = [];
+        command.args.forEach((arg, index)=>{
+            if (arg.variadic) actionArgs.push(args.slice(index));
+            else actionArgs.push(args[index]);
+        });
+        actionArgs.push(options);
+        return command.commandAction.apply(this, actionArgs);
+    }
+}
+const cac = (name = "")=>new CAC(name);
+const dist = cac;
+var external_pathe_ = __webpack_require__("pathe");
+var external_std_env_ = __webpack_require__("std-env");
+var src_config = __webpack_require__("./src/config.ts");
+var helper = __webpack_require__("./src/utils/helper.ts");
+function initNodeEnv() {
+    if (!process.env.NODE_ENV) process.env.NODE_ENV = 'test';
+}
+function prepareCli() {
+    initNodeEnv();
+    const { npm_execpath } = process.env;
+    if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
+}
+function showRstest() {
+    logger.k.greet("  Rstest v0.0.1");
+    logger.k.log('');
+}
+const applyCommonOptions = (cli)=>{
+    cli.option('-c, --config <config>', 'Specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'Specify the loader to load the config file, can be `jiti` or `native`', {
+        default: 'jiti'
+    }).option('-r, --root <root>', 'Specify the project root directory, can be an absolute path or a path relative to cwd').option('--globals', 'Provide global APIs').option('-u, --update', 'Update snapshot files').option('--passWithNoTests', 'Allows the test suite to pass when no files are found').option('--printConsoleTrace', 'Print console traces when calling any console method').option('--disableConsoleIntercept', 'Disable console intercept').option('--slowTestThreshold <value>', 'The number of milliseconds after which a test or suite is considered slow').option('-t, --testNamePattern <value>', 'Run only tests with a name that matches the regex').option('--testEnvironment <name>', 'The environment that will be used for testing').option('--testTimeout <value>', 'Timeout of a test in milliseconds').option('--retry <retry>', 'Number of times to retry a test if it fails').option('--maxConcurrency <value>', 'Maximum number of concurrent tests').option('--clearMocks', 'Automatically clear mock calls, instances, contexts and results before every test').option('--resetMocks', 'Automatically reset mock state before every test').option('--restoreMocks', 'Automatically restore mock state and implementation before every test').option('--unstubGlobals', 'Restores all global variables that were changed with `rstest.stubGlobal` before every test').option('--unstubEnvs', 'Restores all `process.env` values that were changed with `rstest.stubEnv` before every test');
+};
+async function initCli(options) {
+    const cwd = process.cwd();
+    const root = options.root ? (0, helper.ZY)(cwd, options.root) : cwd;
+    const { content: config, filePath: configFilePath } = await (0, src_config.ME)({
+        cwd: root,
+        path: options.config,
+        configLoader: options.configLoader
+    });
+    const keys = [
+        'root',
+        'globals',
+        'passWithNoTests',
+        'update',
+        'testNamePattern',
+        'testTimeout',
+        'clearMocks',
+        'resetMocks',
+        'restoreMocks',
+        'unstubEnvs',
+        'unstubGlobals',
+        'retry',
+        'slowTestThreshold',
+        'maxConcurrency',
+        'printConsoleTrace',
+        'disableConsoleIntercept',
+        'testEnvironment'
+    ];
+    for (const key of keys)if (void 0 !== options[key]) config[key] = options[key];
+    return {
+        config,
+        configFilePath
+    };
+}
+function setupCommands() {
+    const cli = dist('rstest');
+    cli.help();
+    cli.version("0.0.1");
+    applyCommonOptions(cli);
+    cli.command('[...filters]', 'run tests').action(async (filters, options)=>{
+        showRstest();
+        try {
+            const { config } = await initCli(options);
+            const { createRstest } = await __webpack_require__.e("353").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+            if (external_std_env_.isCI) {
+                const rstest = createRstest(config, 'run', filters.map(external_pathe_.normalize));
+                await rstest.runTests();
+            } else {
+                const rstest = createRstest(config, 'watch', filters.map(external_pathe_.normalize));
+                await rstest.runTests();
+            }
+        } catch (err) {
+            logger.k.error('Failed to run Rstest.');
+            logger.k.error(err);
+            process.exit(1);
+        }
+    });
+    cli.command('run [...filters]', 'run tests without watch mode').action(async (filters, options)=>{
+        showRstest();
+        const { config } = await initCli(options);
+        const { createRstest } = await __webpack_require__.e("353").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+        const rstest = createRstest(config, 'run', filters.map(external_pathe_.normalize));
+        try {
+            await rstest.runTests();
+        } catch (err) {
+            for (const reporter of rstest.context.reporters)reporter.onExit?.();
+            logger.k.error('Failed to run Rstest.');
+            logger.k.error((0, helper.Z)(err));
+            process.exit(1);
+        }
+    });
+    cli.command('watch [...filters]', 'run tests in watch mode').action(async (filters, options)=>{
+        showRstest();
+        const { config } = await initCli(options);
+        const { createRstest } = await __webpack_require__.e("353").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+        const rstest = createRstest(config, 'watch', filters.map(external_pathe_.normalize));
+        await rstest.runTests();
+    });
+    cli.command('list [...filters]', 'lists all test files that Rstest will run').option('--filesOnly', 'only list the test files').option('--json [boolean/path]', 'print tests as JSON or write to a file').action(async (filters, options)=>{
+        try {
+            const { config } = await initCli(options);
+            const { createRstest } = await __webpack_require__.e("353").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+            const rstest = createRstest(config, 'list', filters.map(external_pathe_.normalize));
+            await rstest.listTests({
+                filesOnly: options.filesOnly,
+                json: options.json
+            });
+        } catch (err) {
+            logger.k.error('Failed to run Rstest list.');
+            logger.k.error((0, helper.Z)(err));
+            process.exit(1);
+        }
+    });
+    cli.parse();
+}
+async function runCLI() {
+    prepareCli();
+    try {
+        setupCommands();
+    } catch (err) {
+        logger.k.error('Failed to start Rstest CLI.');
+        logger.k.error(err);
+    }
+}
+export { runCLI };