rsbuild-plugin-biome 0.1.1

package/dist/index.js

@@ -0,0 +1,3246 @@
+import { existsSync } from "node:fs";
+import node_path, { relative, sep } from "node:path";
+import promises from "node:fs/promises";
+import node_process from "node:process";
+import { builtinModules } from "node:module";
+import node_util, { stripVTControlCharacters } from "node:util";
+import node_os from "node:os";
+import node_tty from "node:tty";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_os_74b4b876 from "node:os";
+var __webpack_modules__ = {};
+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](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+__webpack_require__.add({
+    "../../node_modules/cross-spawn/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const cp = __webpack_require__("child_process");
+        const parse = __webpack_require__("../../node_modules/cross-spawn/lib/parse.js");
+        const enoent = __webpack_require__("../../node_modules/cross-spawn/lib/enoent.js");
+        function spawn(command, args, options) {
+            const parsed = parse(command, args, options);
+            const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+            enoent.hookChildProcess(spawned, parsed);
+            return spawned;
+        }
+        function spawnSync(command, args, options) {
+            const parsed = parse(command, args, options);
+            const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+            result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+            return result;
+        }
+        module.exports = spawn;
+        module.exports.spawn = spawn;
+        module.exports.sync = spawnSync;
+        module.exports._parse = parse;
+        module.exports._enoent = enoent;
+    },
+    "../../node_modules/cross-spawn/lib/enoent.js" (module) {
+        const isWin = 'win32' === process.platform;
+        function notFoundError(original, syscall) {
+            return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+                code: 'ENOENT',
+                errno: 'ENOENT',
+                syscall: `${syscall} ${original.command}`,
+                path: original.command,
+                spawnargs: original.args
+            });
+        }
+        function hookChildProcess(cp, parsed) {
+            if (!isWin) return;
+            const originalEmit = cp.emit;
+            cp.emit = function(name, arg1) {
+                if ('exit' === name) {
+                    const err = verifyENOENT(arg1, parsed);
+                    if (err) return originalEmit.call(cp, 'error', err);
+                }
+                return originalEmit.apply(cp, arguments);
+            };
+        }
+        function verifyENOENT(status, parsed) {
+            if (isWin && 1 === status && !parsed.file) return notFoundError(parsed.original, 'spawn');
+            return null;
+        }
+        function verifyENOENTSync(status, parsed) {
+            if (isWin && 1 === status && !parsed.file) return notFoundError(parsed.original, 'spawnSync');
+            return null;
+        }
+        module.exports = {
+            hookChildProcess,
+            verifyENOENT,
+            verifyENOENTSync,
+            notFoundError
+        };
+    },
+    "../../node_modules/cross-spawn/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const resolveCommand = __webpack_require__("../../node_modules/cross-spawn/lib/util/resolveCommand.js");
+        const escape = __webpack_require__("../../node_modules/cross-spawn/lib/util/escape.js");
+        const readShebang = __webpack_require__("../../node_modules/cross-spawn/lib/util/readShebang.js");
+        const isWin = 'win32' === process.platform;
+        const isExecutableRegExp = /\.(?:com|exe)$/i;
+        const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+        function detectShebang(parsed) {
+            parsed.file = resolveCommand(parsed);
+            const shebang = parsed.file && readShebang(parsed.file);
+            if (shebang) {
+                parsed.args.unshift(parsed.file);
+                parsed.command = shebang;
+                return resolveCommand(parsed);
+            }
+            return parsed.file;
+        }
+        function parseNonShell(parsed) {
+            if (!isWin) return parsed;
+            const commandFile = detectShebang(parsed);
+            const needsShell = !isExecutableRegExp.test(commandFile);
+            if (parsed.options.forceShell || needsShell) {
+                const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+                parsed.command = path.normalize(parsed.command);
+                parsed.command = escape.command(parsed.command);
+                parsed.args = parsed.args.map((arg)=>escape.argument(arg, needsDoubleEscapeMetaChars));
+                const shellCommand = [
+                    parsed.command
+                ].concat(parsed.args).join(' ');
+                parsed.args = [
+                    '/d',
+                    '/s',
+                    '/c',
+                    `"${shellCommand}"`
+                ];
+                parsed.command = process.env.comspec || 'cmd.exe';
+                parsed.options.windowsVerbatimArguments = true;
+            }
+            return parsed;
+        }
+        function parse(command, args, options) {
+            if (args && !Array.isArray(args)) {
+                options = args;
+                args = null;
+            }
+            args = args ? args.slice(0) : [];
+            options = Object.assign({}, options);
+            const parsed = {
+                command,
+                args,
+                options,
+                file: void 0,
+                original: {
+                    command,
+                    args
+                }
+            };
+            return options.shell ? parsed : parseNonShell(parsed);
+        }
+        module.exports = parse;
+    },
+    "../../node_modules/cross-spawn/lib/util/escape.js" (module) {
+        const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+        function escapeCommand(arg) {
+            arg = arg.replace(metaCharsRegExp, '^$1');
+            return arg;
+        }
+        function escapeArgument(arg, doubleEscapeMetaChars) {
+            arg = `${arg}`;
+            arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+            arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
+            arg = `"${arg}"`;
+            arg = arg.replace(metaCharsRegExp, '^$1');
+            if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, '^$1');
+            return arg;
+        }
+        module.exports.command = escapeCommand;
+        module.exports.argument = escapeArgument;
+    },
+    "../../node_modules/cross-spawn/lib/util/readShebang.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fs = __webpack_require__("fs");
+        const shebangCommand = __webpack_require__("../../node_modules/shebang-command/index.js");
+        function readShebang(command) {
+            const size = 150;
+            const buffer = Buffer.alloc(size);
+            let fd;
+            try {
+                fd = fs.openSync(command, 'r');
+                fs.readSync(fd, buffer, 0, size, 0);
+                fs.closeSync(fd);
+            } catch (e) {}
+            return shebangCommand(buffer.toString());
+        }
+        module.exports = readShebang;
+    },
+    "../../node_modules/cross-spawn/lib/util/resolveCommand.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const which = __webpack_require__("../../node_modules/which/which.js");
+        const getPathKey = __webpack_require__("../../node_modules/path-key/index.js");
+        function resolveCommandAttempt(parsed, withoutPathExt) {
+            const env = parsed.options.env || process.env;
+            const cwd = process.cwd();
+            const hasCustomCwd = null != parsed.options.cwd;
+            const shouldSwitchCwd = hasCustomCwd && void 0 !== process.chdir && !process.chdir.disabled;
+            if (shouldSwitchCwd) try {
+                process.chdir(parsed.options.cwd);
+            } catch (err) {}
+            let resolved;
+            try {
+                resolved = which.sync(parsed.command, {
+                    path: env[getPathKey({
+                        env
+                    })],
+                    pathExt: withoutPathExt ? path.delimiter : void 0
+                });
+            } catch (e) {} finally{
+                if (shouldSwitchCwd) process.chdir(cwd);
+            }
+            if (resolved) resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+            return resolved;
+        }
+        function resolveCommand(parsed) {
+            return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+        }
+        module.exports = resolveCommand;
+    },
+    "../../node_modules/isexe/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        __webpack_require__("fs");
+        var core;
+        core = 'win32' === process.platform || global.TESTING_WINDOWS ? __webpack_require__("../../node_modules/isexe/windows.js") : __webpack_require__("../../node_modules/isexe/mode.js");
+        module.exports = isexe;
+        isexe.sync = sync;
+        function isexe(path, options, cb) {
+            if ('function' == typeof options) {
+                cb = options;
+                options = {};
+            }
+            if (!cb) {
+                if ('function' != typeof Promise) throw new TypeError('callback not provided');
+                return new Promise(function(resolve, reject) {
+                    isexe(path, options || {}, function(er, is) {
+                        if (er) reject(er);
+                        else resolve(is);
+                    });
+                });
+            }
+            core(path, options || {}, function(er, is) {
+                if (er) {
+                    if ('EACCES' === er.code || options && options.ignoreErrors) {
+                        er = null;
+                        is = false;
+                    }
+                }
+                cb(er, is);
+            });
+        }
+        function sync(path, options) {
+            try {
+                return core.sync(path, options || {});
+            } catch (er) {
+                if (options && options.ignoreErrors || 'EACCES' === er.code) return false;
+                throw er;
+            }
+        }
+    },
+    "../../node_modules/isexe/mode.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = isexe;
+        isexe.sync = sync;
+        var fs = __webpack_require__("fs");
+        function isexe(path, options, cb) {
+            fs.stat(path, function(er, stat) {
+                cb(er, er ? false : checkStat(stat, options));
+            });
+        }
+        function sync(path, options) {
+            return checkStat(fs.statSync(path), options);
+        }
+        function checkStat(stat, options) {
+            return stat.isFile() && checkMode(stat, options);
+        }
+        function checkMode(stat, options) {
+            var mod = stat.mode;
+            var uid = stat.uid;
+            var gid = stat.gid;
+            var myUid = void 0 !== options.uid ? options.uid : process.getuid && process.getuid();
+            var myGid = void 0 !== options.gid ? options.gid : process.getgid && process.getgid();
+            var u = parseInt('100', 8);
+            var g = parseInt('010', 8);
+            var o = parseInt('001', 8);
+            var ug = u | g;
+            var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && 0 === myUid;
+            return ret;
+        }
+    },
+    "../../node_modules/isexe/windows.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = isexe;
+        isexe.sync = sync;
+        var fs = __webpack_require__("fs");
+        function checkPathExt(path, options) {
+            var pathext = void 0 !== options.pathExt ? options.pathExt : process.env.PATHEXT;
+            if (!pathext) return true;
+            pathext = pathext.split(';');
+            if (-1 !== pathext.indexOf('')) return true;
+            for(var i = 0; i < pathext.length; i++){
+                var p = pathext[i].toLowerCase();
+                if (p && path.substr(-p.length).toLowerCase() === p) return true;
+            }
+            return false;
+        }
+        function checkStat(stat, path, options) {
+            if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+            return checkPathExt(path, options);
+        }
+        function isexe(path, options, cb) {
+            fs.stat(path, function(er, stat) {
+                cb(er, er ? false : checkStat(stat, path, options));
+            });
+        }
+        function sync(path, options) {
+            return checkStat(fs.statSync(path), path, options);
+        }
+    },
+    "../../node_modules/js-tokens/index.js" (__unused_rspack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports["default"] = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
+        exports.matchToToken = function(match) {
+            var token = {
+                type: "invalid",
+                value: match[0],
+                closed: void 0
+            };
+            if (match[1]) token.type = "string", token.closed = !!(match[3] || match[4]);
+            else if (match[5]) token.type = "comment";
+            else if (match[6]) token.type = "comment", token.closed = !!match[7];
+            else if (match[8]) token.type = "regex";
+            else if (match[9]) token.type = "number";
+            else if (match[10]) token.type = "name";
+            else if (match[11]) token.type = "punctuator";
+            else if (match[12]) token.type = "whitespace";
+            return token;
+        };
+    },
+    "../../node_modules/path-key/index.js" (module) {
+        const pathKey = (options = {})=>{
+            const environment = options.env || process.env;
+            const platform = options.platform || process.platform;
+            if ('win32' !== platform) return 'PATH';
+            return Object.keys(environment).reverse().find((key)=>'PATH' === key.toUpperCase()) || 'Path';
+        };
+        module.exports = pathKey;
+        module.exports["default"] = pathKey;
+    },
+    "../../node_modules/picocolors/picocolors.js" (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/shebang-command/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const shebangRegex = __webpack_require__("../../node_modules/shebang-regex/index.js");
+        module.exports = (string = '')=>{
+            const match = string.match(shebangRegex);
+            if (!match) return null;
+            const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
+            const binary = path.split('/').pop();
+            if ('env' === binary) return argument;
+            return argument ? `${binary} ${argument}` : binary;
+        };
+    },
+    "../../node_modules/shebang-regex/index.js" (module) {
+        module.exports = /^#!(.*)/;
+    },
+    "../../node_modules/which/which.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const isWindows = 'win32' === process.platform || 'cygwin' === process.env.OSTYPE || 'msys' === process.env.OSTYPE;
+        const path = __webpack_require__("path");
+        const COLON = isWindows ? ';' : ':';
+        const isexe = __webpack_require__("../../node_modules/isexe/index.js");
+        const getNotFoundError = (cmd)=>Object.assign(new Error(`not found: ${cmd}`), {
+                code: 'ENOENT'
+            });
+        const getPathInfo = (cmd, opt)=>{
+            const colon = opt.colon || COLON;
+            const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [
+                ''
+            ] : [
+                ...isWindows ? [
+                    process.cwd()
+                ] : [],
+                ...(opt.path || process.env.PATH || '').split(colon)
+            ];
+            const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM' : '';
+            const pathExt = isWindows ? pathExtExe.split(colon) : [
+                ''
+            ];
+            if (isWindows) {
+                if (-1 !== cmd.indexOf('.') && '' !== pathExt[0]) pathExt.unshift('');
+            }
+            return {
+                pathEnv,
+                pathExt,
+                pathExtExe
+            };
+        };
+        const which = (cmd, opt, cb)=>{
+            if ('function' == typeof opt) {
+                cb = opt;
+                opt = {};
+            }
+            if (!opt) opt = {};
+            const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+            const found = [];
+            const step = (i)=>new Promise((resolve, reject)=>{
+                    if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+                    const ppRaw = pathEnv[i];
+                    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+                    const pCmd = path.join(pathPart, cmd);
+                    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+                    resolve(subStep(p, i, 0));
+                });
+            const subStep = (p, i, ii)=>new Promise((resolve, reject)=>{
+                    if (ii === pathExt.length) return resolve(step(i + 1));
+                    const ext = pathExt[ii];
+                    isexe(p + ext, {
+                        pathExt: pathExtExe
+                    }, (er, is)=>{
+                        if (!er && is) if (!opt.all) return resolve(p + ext);
+                        else found.push(p + ext);
+                        return resolve(subStep(p, i, ii + 1));
+                    });
+                });
+            return cb ? step(0).then((res)=>cb(null, res), cb) : step(0);
+        };
+        const whichSync = (cmd, opt)=>{
+            opt = opt || {};
+            const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+            const found = [];
+            for(let i = 0; i < pathEnv.length; i++){
+                const ppRaw = pathEnv[i];
+                const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+                const pCmd = path.join(pathPart, cmd);
+                const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+                for(let j = 0; j < pathExt.length; j++){
+                    const cur = p + pathExt[j];
+                    try {
+                        const is = isexe.sync(cur, {
+                            pathExt: pathExtExe
+                        });
+                        if (is) if (!opt.all) return cur;
+                        else found.push(cur);
+                    } catch (ex) {}
+                }
+            }
+            if (opt.all && found.length) return found;
+            if (opt.nothrow) return null;
+            throw getNotFoundError(cmd);
+        };
+        module.exports = which;
+        which.sync = whichSync;
+    },
+    child_process (module) {
+        module.exports = __rspack_createRequire_require("child_process");
+    },
+    fs (module) {
+        module.exports = __rspack_createRequire_require("fs");
+    },
+    path (module) {
+        module.exports = __rspack_createRequire_require("path");
+    },
+    "../../node_modules/@babel/code-frame/lib/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var picocolors = __webpack_require__("../../node_modules/picocolors/picocolors.js");
+        var jsTokens = __webpack_require__("../../node_modules/js-tokens/index.js");
+        var helperValidatorIdentifier = __webpack_require__("../../node_modules/@babel/helper-validator-identifier/lib/index.js");
+        function isColorSupported() {
+            return "object" == typeof process && ("0" === process.env.FORCE_COLOR || "false" === process.env.FORCE_COLOR) ? false : picocolors.isColorSupported;
+        }
+        const compose = (f, g)=>(v)=>f(g(v));
+        function buildDefs(colors) {
+            return {
+                keyword: colors.cyan,
+                capitalized: colors.yellow,
+                jsxIdentifier: colors.yellow,
+                punctuator: colors.yellow,
+                number: colors.magenta,
+                string: colors.green,
+                regex: colors.magenta,
+                comment: colors.gray,
+                invalid: compose(compose(colors.white, colors.bgRed), colors.bold),
+                gutter: colors.gray,
+                marker: compose(colors.red, colors.bold),
+                message: compose(colors.red, colors.bold),
+                reset: colors.reset
+            };
+        }
+        const defsOn = buildDefs(picocolors.createColors(true));
+        const defsOff = buildDefs(picocolors.createColors(false));
+        function getDefs(enabled) {
+            return enabled ? defsOn : defsOff;
+        }
+        const sometimesKeywords = new Set([
+            "as",
+            "async",
+            "from",
+            "get",
+            "of",
+            "set"
+        ]);
+        const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+        const BRACKET = /^[()[\]{}]$/;
+        let tokenize;
+        const JSX_TAG = /^[a-z][\w-]*$/i;
+        const getTokenType = function(token, offset, text) {
+            if ("name" === token.type) {
+                const tokenValue = token.value;
+                if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) return "keyword";
+                if (JSX_TAG.test(tokenValue) && ("<" === text[offset - 1] || "</" === text.slice(offset - 2, offset))) return "jsxIdentifier";
+                const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+                if (firstChar !== firstChar.toLowerCase()) return "capitalized";
+            }
+            if ("punctuator" === token.type && BRACKET.test(token.value)) return "bracket";
+            if ("invalid" === token.type && ("@" === token.value || "#" === token.value)) return "punctuator";
+            return token.type;
+        };
+        tokenize = function*(text) {
+            let match;
+            while(match = jsTokens.default.exec(text)){
+                const token = jsTokens.matchToToken(match);
+                yield {
+                    type: getTokenType(token, match.index, text),
+                    value: token.value
+                };
+            }
+        };
+        function highlight(text) {
+            if ("" === text) return "";
+            const defs = getDefs(true);
+            let highlighted = "";
+            for (const { type, value } of tokenize(text))if (type in defs) highlighted += value.split(NEWLINE$1).map((str)=>defs[type](str)).join("\n");
+            else highlighted += value;
+            return highlighted;
+        }
+        const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+        function getMarkerLines(loc, source, opts, startLineBaseZero) {
+            const startLoc = Object.assign({
+                column: 0,
+                line: -1
+            }, loc.start);
+            const endLoc = Object.assign({}, startLoc, loc.end);
+            const { linesAbove = 2, linesBelow = 3 } = opts || {};
+            const startLine = startLoc.line - startLineBaseZero;
+            const startColumn = startLoc.column;
+            const endLine = endLoc.line - startLineBaseZero;
+            const endColumn = endLoc.column;
+            let start = Math.max(startLine - (linesAbove + 1), 0);
+            let end = Math.min(source.length, endLine + linesBelow);
+            if (-1 === startLine) start = 0;
+            if (-1 === endLine) end = source.length;
+            const lineDiff = endLine - startLine;
+            const markerLines = {};
+            if (lineDiff) for(let i = 0; i <= lineDiff; i++){
+                const lineNumber = i + startLine;
+                if (startColumn) if (0 === i) {
+                    const sourceLength = source[lineNumber - 1].length;
+                    markerLines[lineNumber] = [
+                        startColumn,
+                        sourceLength - startColumn + 1
+                    ];
+                } else if (i === lineDiff) markerLines[lineNumber] = [
+                    0,
+                    endColumn
+                ];
+                else {
+                    const sourceLength = source[lineNumber - i].length;
+                    markerLines[lineNumber] = [
+                        0,
+                        sourceLength
+                    ];
+                }
+                else markerLines[lineNumber] = true;
+            }
+            else if (startColumn === endColumn) if (startColumn) markerLines[startLine] = [
+                startColumn,
+                0
+            ];
+            else markerLines[startLine] = true;
+            else markerLines[startLine] = [
+                startColumn,
+                endColumn - startColumn
+            ];
+            return {
+                start,
+                end,
+                markerLines
+            };
+        }
+        function codeFrameColumns(rawLines, loc, opts = {}) {
+            const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+            const startLineBaseZero = (opts.startLine || 1) - 1;
+            const defs = getDefs(shouldHighlight);
+            const lines = rawLines.split(NEWLINE);
+            const { start, end, markerLines } = getMarkerLines(loc, lines, opts, startLineBaseZero);
+            const hasColumns = loc.start && "number" == typeof loc.start.column;
+            const numberMaxWidth = String(end + startLineBaseZero).length;
+            const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
+            let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index)=>{
+                const number = start + 1 + index;
+                const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
+                const gutter = ` ${paddedNumber} |`;
+                const hasMarker = markerLines[number];
+                const lastMarkerLine = !markerLines[number + 1];
+                if (!hasMarker) return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+                {
+                    let markerLine = "";
+                    if (Array.isArray(hasMarker)) {
+                        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+                        const numberOfMarkers = hasMarker[1] || 1;
+                        markerLine = [
+                            "\n ",
+                            defs.gutter(gutter.replace(/\d/g, " ")),
+                            " ",
+                            markerSpacing,
+                            defs.marker("^").repeat(numberOfMarkers)
+                        ].join("");
+                        if (lastMarkerLine && opts.message) markerLine += " " + defs.message(opts.message);
+                    }
+                    return [
+                        defs.marker(">"),
+                        defs.gutter(gutter),
+                        line.length > 0 ? ` ${line}` : "",
+                        markerLine
+                    ].join("");
+                }
+            }).join("\n");
+            if (opts.message && !hasColumns) frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+            if (shouldHighlight) return defs.reset(frame);
+            return frame;
+        }
+        exports.gl = codeFrameColumns;
+    },
+    "../../node_modules/@babel/helper-validator-identifier/lib/identifier.js" (__unused_rspack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.isIdentifierChar = isIdentifierChar;
+        exports.isIdentifierName = isIdentifierName;
+        exports.isIdentifierStart = isIdentifierStart;
+        let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088f\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5c\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdc-\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7dc\ua7f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+        let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1add\u1ae0-\u1aeb\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+        const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+        const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+        nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+        const astralIdentifierStartCodes = [
+            0,
+            11,
+            2,
+            25,
+            2,
+            18,
+            2,
+            1,
+            2,
+            14,
+            3,
+            13,
+            35,
+            122,
+            70,
+            52,
+            268,
+            28,
+            4,
+            48,
+            48,
+            31,
+            14,
+            29,
+            6,
+            37,
+            11,
+            29,
+            3,
+            35,
+            5,
+            7,
+            2,
+            4,
+            43,
+            157,
+            19,
+            35,
+            5,
+            35,
+            5,
+            39,
+            9,
+            51,
+            13,
+            10,
+            2,
+            14,
+            2,
+            6,
+            2,
+            1,
+            2,
+            10,
+            2,
+            14,
+            2,
+            6,
+            2,
+            1,
+            4,
+            51,
+            13,
+            310,
+            10,
+            21,
+            11,
+            7,
+            25,
+            5,
+            2,
+            41,
+            2,
+            8,
+            70,
+            5,
+            3,
+            0,
+            2,
+            43,
+            2,
+            1,
+            4,
+            0,
+            3,
+            22,
+            11,
+            22,
+            10,
+            30,
+            66,
+            18,
+            2,
+            1,
+            11,
+            21,
+            11,
+            25,
+            7,
+            25,
+            39,
+            55,
+            7,
+            1,
+            65,
+            0,
+            16,
+            3,
+            2,
+            2,
+            2,
+            28,
+            43,
+            28,
+            4,
+            28,
+            36,
+            7,
+            2,
+            27,
+            28,
+            53,
+            11,
+            21,
+            11,
+            18,
+            14,
+            17,
+            111,
+            72,
+            56,
+            50,
+            14,
+            50,
+            14,
+            35,
+            39,
+            27,
+            10,
+            22,
+            251,
+            41,
+            7,
+            1,
+            17,
+            5,
+            57,
+            28,
+            11,
+            0,
+            9,
+            21,
+            43,
+            17,
+            47,
+            20,
+            28,
+            22,
+            13,
+            52,
+            58,
+            1,
+            3,
+            0,
+            14,
+            44,
+            33,
+            24,
+            27,
+            35,
+            30,
+            0,
+            3,
+            0,
+            9,
+            34,
+            4,
+            0,
+            13,
+            47,
+            15,
+            3,
+            22,
+            0,
+            2,
+            0,
+            36,
+            17,
+            2,
+            24,
+            20,
+            1,
+            64,
+            6,
+            2,
+            0,
+            2,
+            3,
+            2,
+            14,
+            2,
+            9,
+            8,
+            46,
+            39,
+            7,
+            3,
+            1,
+            3,
+            21,
+            2,
+            6,
+            2,
+            1,
+            2,
+            4,
+            4,
+            0,
+            19,
+            0,
+            13,
+            4,
+            31,
+            9,
+            2,
+            0,
+            3,
+            0,
+            2,
+            37,
+            2,
+            0,
+            26,
+            0,
+            2,
+            0,
+            45,
+            52,
+            19,
+            3,
+            21,
+            2,
+            31,
+            47,
+            21,
+            1,
+            2,
+            0,
+            185,
+            46,
+            42,
+            3,
+            37,
+            47,
+            21,
+            0,
+            60,
+            42,
+            14,
+            0,
+            72,
+            26,
+            38,
+            6,
+            186,
+            43,
+            117,
+            63,
+            32,
+            7,
+            3,
+            0,
+            3,
+            7,
+            2,
+            1,
+            2,
+            23,
+            16,
+            0,
+            2,
+            0,
+            95,
+            7,
+            3,
+            38,
+            17,
+            0,
+            2,
+            0,
+            29,
+            0,
+            11,
+            39,
+            8,
+            0,
+            22,
+            0,
+            12,
+            45,
+            20,
+            0,
+            19,
+            72,
+            200,
+            32,
+            32,
+            8,
+            2,
+            36,
+            18,
+            0,
+            50,
+            29,
+            113,
+            6,
+            2,
+            1,
+            2,
+            37,
+            22,
+            0,
+            26,
+            5,
+            2,
+            1,
+            2,
+            31,
+            15,
+            0,
+            24,
+            43,
+            261,
+            18,
+            16,
+            0,
+            2,
+            12,
+            2,
+            33,
+            125,
+            0,
+            80,
+            921,
+            103,
+            110,
+            18,
+            195,
+            2637,
+            96,
+            16,
+            1071,
+            18,
+            5,
+            26,
+            3994,
+            6,
+            582,
+            6842,
+            29,
+            1763,
+            568,
+            8,
+            30,
+            18,
+            78,
+            18,
+            29,
+            19,
+            47,
+            17,
+            3,
+            32,
+            20,
+            6,
+            18,
+            433,
+            44,
+            212,
+            63,
+            33,
+            24,
+            3,
+            24,
+            45,
+            74,
+            6,
+            0,
+            67,
+            12,
+            65,
+            1,
+            2,
+            0,
+            15,
+            4,
+            10,
+            7381,
+            42,
+            31,
+            98,
+            114,
+            8702,
+            3,
+            2,
+            6,
+            2,
+            1,
+            2,
+            290,
+            16,
+            0,
+            30,
+            2,
+            3,
+            0,
+            15,
+            3,
+            9,
+            395,
+            2309,
+            106,
+            6,
+            12,
+            4,
+            8,
+            8,
+            9,
+            5991,
+            84,
+            2,
+            70,
+            2,
+            1,
+            3,
+            0,
+            3,
+            1,
+            3,
+            3,
+            2,
+            11,
+            2,
+            0,
+            2,
+            6,
+            2,
+            64,
+            2,
+            3,
+            3,
+            7,
+            2,
+            6,
+            2,
+            27,
+            2,
+            3,
+            2,
+            4,
+            2,
+            0,
+            4,
+            6,
+            2,
+            339,
+            3,
+            24,
+            2,
+            24,
+            2,
+            30,
+            2,
+            24,
+            2,
+            30,
+            2,
+            24,
+            2,
+            30,
+            2,
+            24,
+            2,
+            30,
+            2,
+            24,
+            2,
+            7,
+            1845,
+            30,
+            7,
+            5,
+            262,
+            61,
+            147,
+            44,
+            11,
+            6,
+            17,
+            0,
+            322,
+            29,
+            19,
+            43,
+            485,
+            27,
+            229,
+            29,
+            3,
+            0,
+            208,
+            30,
+            2,
+            2,
+            2,
+            1,
+            2,
+            6,
+            3,
+            4,
+            10,
+            1,
+            225,
+            6,
+            2,
+            3,
+            2,
+            1,
+            2,
+            14,
+            2,
+            196,
+            60,
+            67,
+            8,
+            0,
+            1205,
+            3,
+            2,
+            26,
+            2,
+            1,
+            2,
+            0,
+            3,
+            0,
+            2,
+            9,
+            2,
+            3,
+            2,
+            0,
+            2,
+            0,
+            7,
+            0,
+            5,
+            0,
+            2,
+            0,
+            2,
+            0,
+            2,
+            2,
+            2,
+            1,
+            2,
+            0,
+            3,
+            0,
+            2,
+            0,
+            2,
+            0,
+            2,
+            0,
+            2,
+            0,
+            2,
+            1,
+            2,
+            0,
+            3,
+            3,
+            2,
+            6,
+            2,
+            3,
+            2,
+            3,
+            2,
+            0,
+            2,
+            9,
+            2,
+            16,
+            6,
+            2,
+            2,
+            4,
+            2,
+            16,
+            4421,
+            42719,
+            33,
+            4381,
+            3,
+            5773,
+            3,
+            7472,
+            16,
+            621,
+            2467,
+            541,
+            1507,
+            4938,
+            6,
+            8489
+        ];
+        const astralIdentifierCodes = [
+            509,
+            0,
+            227,
+            0,
+            150,
+            4,
+            294,
+            9,
+            1368,
+            2,
+            2,
+            1,
+            6,
+            3,
+            41,
+            2,
+            5,
+            0,
+            166,
+            1,
+            574,
+            3,
+            9,
+            9,
+            7,
+            9,
+            32,
+            4,
+            318,
+            1,
+            78,
+            5,
+            71,
+            10,
+            50,
+            3,
+            123,
+            2,
+            54,
+            14,
+            32,
+            10,
+            3,
+            1,
+            11,
+            3,
+            46,
+            10,
+            8,
+            0,
+            46,
+            9,
+            7,
+            2,
+            37,
+            13,
+            2,
+            9,
+            6,
+            1,
+            45,
+            0,
+            13,
+            2,
+            49,
+            13,
+            9,
+            3,
+            2,
+            11,
+            83,
+            11,
+            7,
+            0,
+            3,
+            0,
+            158,
+            11,
+            6,
+            9,
+            7,
+            3,
+            56,
+            1,
+            2,
+            6,
+            3,
+            1,
+            3,
+            2,
+            10,
+            0,
+            11,
+            1,
+            3,
+            6,
+            4,
+            4,
+            68,
+            8,
+            2,
+            0,
+            3,
+            0,
+            2,
+            3,
+            2,
+            4,
+            2,
+            0,
+            15,
+            1,
+            83,
+            17,
+            10,
+            9,
+            5,
+            0,
+            82,
+            19,
+            13,
+            9,
+            214,
+            6,
+            3,
+            8,
+            28,
+            1,
+            83,
+            16,
+            16,
+            9,
+            82,
+            12,
+            9,
+            9,
+            7,
+            19,
+            58,
+            14,
+            5,
+            9,
+            243,
+            14,
+            166,
+            9,
+            71,
+            5,
+            2,
+            1,
+            3,
+            3,
+            2,
+            0,
+            2,
+            1,
+            13,
+            9,
+            120,
+            6,
+            3,
+            6,
+            4,
+            0,
+            29,
+            9,
+            41,
+            6,
+            2,
+            3,
+            9,
+            0,
+            10,
+            10,
+            47,
+            15,
+            199,
+            7,
+            137,
+            9,
+            54,
+            7,
+            2,
+            7,
+            17,
+            9,
+            57,
+            21,
+            2,
+            13,
+            123,
+            5,
+            4,
+            0,
+            2,
+            1,
+            2,
+            6,
+            2,
+            0,
+            9,
+            9,
+            49,
+            4,
+            2,
+            1,
+            2,
+            4,
+            9,
+            9,
+            55,
+            9,
+            266,
+            3,
+            10,
+            1,
+            2,
+            0,
+            49,
+            6,
+            4,
+            4,
+            14,
+            10,
+            5350,
+            0,
+            7,
+            14,
+            11465,
+            27,
+            2343,
+            9,
+            87,
+            9,
+            39,
+            4,
+            60,
+            6,
+            26,
+            9,
+            535,
+            9,
+            470,
+            0,
+            2,
+            54,
+            8,
+            3,
+            82,
+            0,
+            12,
+            1,
+            19628,
+            1,
+            4178,
+            9,
+            519,
+            45,
+            3,
+            22,
+            543,
+            4,
+            4,
+            5,
+            9,
+            7,
+            3,
+            6,
+            31,
+            3,
+            149,
+            2,
+            1418,
+            49,
+            513,
+            54,
+            5,
+            49,
+            9,
+            0,
+            15,
+            0,
+            23,
+            4,
+            2,
+            14,
+            1361,
+            6,
+            2,
+            16,
+            3,
+            6,
+            2,
+            1,
+            2,
+            4,
+            101,
+            0,
+            161,
+            6,
+            10,
+            9,
+            357,
+            0,
+            62,
+            13,
+            499,
+            13,
+            245,
+            1,
+            2,
+            9,
+            233,
+            0,
+            3,
+            0,
+            8,
+            1,
+            6,
+            0,
+            475,
+            6,
+            110,
+            6,
+            6,
+            9,
+            4759,
+            9,
+            787719,
+            239
+        ];
+        function isInAstralSet(code, set) {
+            let pos = 0x10000;
+            for(let i = 0, length = set.length; i < length; i += 2){
+                pos += set[i];
+                if (pos > code) break;
+                pos += set[i + 1];
+                if (pos >= code) return true;
+            }
+            return false;
+        }
+        function isIdentifierStart(code) {
+            if (code < 65) return 36 === code;
+            if (code <= 90) return true;
+            if (code < 97) return 95 === code;
+            if (code <= 122) return true;
+            if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+            return isInAstralSet(code, astralIdentifierStartCodes);
+        }
+        function isIdentifierChar(code) {
+            if (code < 48) return 36 === code;
+            if (code < 58) return true;
+            if (code < 65) return false;
+            if (code <= 90) return true;
+            if (code < 97) return 95 === code;
+            if (code <= 122) return true;
+            if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+            return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+        }
+        function isIdentifierName(name) {
+            let isFirst = true;
+            for(let i = 0; i < name.length; i++){
+                let cp = name.charCodeAt(i);
+                if ((0xfc00 & cp) === 0xd800 && i + 1 < name.length) {
+                    const trail = name.charCodeAt(++i);
+                    if ((0xfc00 & trail) === 0xdc00) cp = 0x10000 + ((0x3ff & cp) << 10) + (0x3ff & trail);
+                }
+                if (isFirst) {
+                    isFirst = false;
+                    if (!isIdentifierStart(cp)) return false;
+                } else if (!isIdentifierChar(cp)) return false;
+            }
+            return !isFirst;
+        }
+    },
+    "../../node_modules/@babel/helper-validator-identifier/lib/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        Object.defineProperty(exports, "isIdentifierChar", {
+            enumerable: true,
+            get: function() {
+                return _identifier.isIdentifierChar;
+            }
+        });
+        Object.defineProperty(exports, "isIdentifierName", {
+            enumerable: true,
+            get: function() {
+                return _identifier.isIdentifierName;
+            }
+        });
+        Object.defineProperty(exports, "isIdentifierStart", {
+            enumerable: true,
+            get: function() {
+                return _identifier.isIdentifierStart;
+            }
+        });
+        Object.defineProperty(exports, "isKeyword", {
+            enumerable: true,
+            get: function() {
+                return _keyword.isKeyword;
+            }
+        });
+        Object.defineProperty(exports, "isReservedWord", {
+            enumerable: true,
+            get: function() {
+                return _keyword.isReservedWord;
+            }
+        });
+        Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+            enumerable: true,
+            get: function() {
+                return _keyword.isStrictBindOnlyReservedWord;
+            }
+        });
+        Object.defineProperty(exports, "isStrictBindReservedWord", {
+            enumerable: true,
+            get: function() {
+                return _keyword.isStrictBindReservedWord;
+            }
+        });
+        Object.defineProperty(exports, "isStrictReservedWord", {
+            enumerable: true,
+            get: function() {
+                return _keyword.isStrictReservedWord;
+            }
+        });
+        var _identifier = __webpack_require__("../../node_modules/@babel/helper-validator-identifier/lib/identifier.js");
+        var _keyword = __webpack_require__("../../node_modules/@babel/helper-validator-identifier/lib/keyword.js");
+    },
+    "../../node_modules/@babel/helper-validator-identifier/lib/keyword.js" (__unused_rspack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.isKeyword = isKeyword;
+        exports.isReservedWord = isReservedWord;
+        exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+        exports.isStrictBindReservedWord = isStrictBindReservedWord;
+        exports.isStrictReservedWord = isStrictReservedWord;
+        const reservedWords = {
+            keyword: [
+                "break",
+                "case",
+                "catch",
+                "continue",
+                "debugger",
+                "default",
+                "do",
+                "else",
+                "finally",
+                "for",
+                "function",
+                "if",
+                "return",
+                "switch",
+                "throw",
+                "try",
+                "var",
+                "const",
+                "while",
+                "with",
+                "new",
+                "this",
+                "super",
+                "class",
+                "extends",
+                "export",
+                "import",
+                "null",
+                "true",
+                "false",
+                "in",
+                "instanceof",
+                "typeof",
+                "void",
+                "delete"
+            ],
+            strict: [
+                "implements",
+                "interface",
+                "let",
+                "package",
+                "private",
+                "protected",
+                "public",
+                "static",
+                "yield"
+            ],
+            strictBind: [
+                "eval",
+                "arguments"
+            ]
+        };
+        const keywords = new Set(reservedWords.keyword);
+        const reservedWordsStrictSet = new Set(reservedWords.strict);
+        const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+        function isReservedWord(word, inModule) {
+            return inModule && "await" === word || "enum" === word;
+        }
+        function isStrictReservedWord(word, inModule) {
+            return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+        }
+        function isStrictBindOnlyReservedWord(word) {
+            return reservedWordsStrictBindSet.has(word);
+        }
+        function isStrictBindReservedWord(word, inModule) {
+            return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+        }
+        function isKeyword(word) {
+            return keywords.has(word);
+        }
+    }
+});
+function dashDashArg(agent, agentCommand) {
+    return (args)=>{
+        if (args.length > 1) return [
+            agent,
+            agentCommand,
+            args[0],
+            "--",
+            ...args.slice(1)
+        ];
+        return [
+            agent,
+            agentCommand,
+            args[0]
+        ];
+    };
+}
+function denoExecute() {
+    return (args)=>[
+            "deno",
+            "run",
+            `npm:${args[0]}`,
+            ...args.slice(1)
+        ];
+}
+const npm = {
+    agent: [
+        "npm",
+        0
+    ],
+    run: dashDashArg("npm", "run"),
+    install: [
+        "npm",
+        "i",
+        0
+    ],
+    frozen: [
+        "npm",
+        "ci",
+        0
+    ],
+    global: [
+        "npm",
+        "i",
+        "-g",
+        0
+    ],
+    add: [
+        "npm",
+        "i",
+        0
+    ],
+    upgrade: [
+        "npm",
+        "update",
+        0
+    ],
+    "upgrade-interactive": null,
+    dedupe: [
+        "npm",
+        "dedupe",
+        0
+    ],
+    execute: [
+        "npx",
+        0
+    ],
+    "execute-local": [
+        "npx",
+        0
+    ],
+    uninstall: [
+        "npm",
+        "uninstall",
+        0
+    ],
+    global_uninstall: [
+        "npm",
+        "uninstall",
+        "-g",
+        0
+    ]
+};
+const yarn = {
+    agent: [
+        "yarn",
+        0
+    ],
+    run: [
+        "yarn",
+        "run",
+        0
+    ],
+    install: [
+        "yarn",
+        "install",
+        0
+    ],
+    frozen: [
+        "yarn",
+        "install",
+        "--frozen-lockfile",
+        0
+    ],
+    global: [
+        "yarn",
+        "global",
+        "add",
+        0
+    ],
+    add: [
+        "yarn",
+        "add",
+        0
+    ],
+    upgrade: [
+        "yarn",
+        "upgrade",
+        0
+    ],
+    "upgrade-interactive": [
+        "yarn",
+        "upgrade-interactive",
+        0
+    ],
+    dedupe: null,
+    execute: [
+        "npx",
+        0
+    ],
+    "execute-local": dashDashArg("yarn", "exec"),
+    uninstall: [
+        "yarn",
+        "remove",
+        0
+    ],
+    global_uninstall: [
+        "yarn",
+        "global",
+        "remove",
+        0
+    ]
+};
+const yarnBerry = {
+    ...yarn,
+    frozen: [
+        "yarn",
+        "install",
+        "--immutable",
+        0
+    ],
+    upgrade: [
+        "yarn",
+        "up",
+        0
+    ],
+    "upgrade-interactive": [
+        "yarn",
+        "up",
+        "-i",
+        0
+    ],
+    dedupe: [
+        "yarn",
+        "dedupe",
+        0
+    ],
+    execute: [
+        "yarn",
+        "dlx",
+        0
+    ],
+    "execute-local": [
+        "yarn",
+        "exec",
+        0
+    ],
+    global: [
+        "npm",
+        "i",
+        "-g",
+        0
+    ],
+    global_uninstall: [
+        "npm",
+        "uninstall",
+        "-g",
+        0
+    ]
+};
+const pnpm = {
+    agent: [
+        "pnpm",
+        0
+    ],
+    run: [
+        "pnpm",
+        "run",
+        0
+    ],
+    install: [
+        "pnpm",
+        "i",
+        0
+    ],
+    frozen: [
+        "pnpm",
+        "i",
+        "--frozen-lockfile",
+        0
+    ],
+    global: [
+        "pnpm",
+        "add",
+        "-g",
+        0
+    ],
+    add: [
+        "pnpm",
+        "add",
+        0
+    ],
+    upgrade: [
+        "pnpm",
+        "update",
+        0
+    ],
+    "upgrade-interactive": [
+        "pnpm",
+        "update",
+        "-i",
+        0
+    ],
+    dedupe: [
+        "pnpm",
+        "dedupe",
+        0
+    ],
+    execute: [
+        "pnpm",
+        "dlx",
+        0
+    ],
+    "execute-local": [
+        "pnpm",
+        "exec",
+        0
+    ],
+    uninstall: [
+        "pnpm",
+        "remove",
+        0
+    ],
+    global_uninstall: [
+        "pnpm",
+        "remove",
+        "--global",
+        0
+    ]
+};
+const bun = {
+    agent: [
+        "bun",
+        0
+    ],
+    run: [
+        "bun",
+        "run",
+        0
+    ],
+    install: [
+        "bun",
+        "install",
+        0
+    ],
+    frozen: [
+        "bun",
+        "install",
+        "--frozen-lockfile",
+        0
+    ],
+    global: [
+        "bun",
+        "add",
+        "-g",
+        0
+    ],
+    add: [
+        "bun",
+        "add",
+        0
+    ],
+    upgrade: [
+        "bun",
+        "update",
+        0
+    ],
+    "upgrade-interactive": [
+        "bun",
+        "update",
+        "-i",
+        0
+    ],
+    dedupe: null,
+    execute: [
+        "bun",
+        "x",
+        0
+    ],
+    "execute-local": [
+        "bun",
+        "x",
+        0
+    ],
+    uninstall: [
+        "bun",
+        "remove",
+        0
+    ],
+    global_uninstall: [
+        "bun",
+        "remove",
+        "-g",
+        0
+    ]
+};
+const deno = {
+    agent: [
+        "deno",
+        0
+    ],
+    run: [
+        "deno",
+        "task",
+        0
+    ],
+    install: [
+        "deno",
+        "install",
+        0
+    ],
+    frozen: [
+        "deno",
+        "install",
+        "--frozen",
+        0
+    ],
+    global: [
+        "deno",
+        "install",
+        "-g",
+        0
+    ],
+    add: [
+        "deno",
+        "add",
+        0
+    ],
+    upgrade: [
+        "deno",
+        "outdated",
+        "--update",
+        0
+    ],
+    "upgrade-interactive": [
+        "deno",
+        "outdated",
+        "--update",
+        0
+    ],
+    dedupe: null,
+    execute: denoExecute(),
+    "execute-local": [
+        "deno",
+        "task",
+        "--eval",
+        0
+    ],
+    uninstall: [
+        "deno",
+        "remove",
+        0
+    ],
+    global_uninstall: [
+        "deno",
+        "uninstall",
+        "-g",
+        0
+    ]
+};
+const COMMANDS = {
+    npm: npm,
+    yarn: yarn,
+    "yarn@berry": yarnBerry,
+    pnpm: pnpm,
+    "pnpm@6": {
+        ...pnpm,
+        run: dashDashArg("pnpm", "run")
+    },
+    bun: bun,
+    deno: deno
+};
+function resolveCommand(agent, command, args) {
+    const value = COMMANDS[agent][command];
+    return constructCommand(value, args);
+}
+function constructCommand(value, args) {
+    if (null == value) return null;
+    const list = "function" == typeof value ? value(args) : value.flatMap((v)=>{
+        if ("number" == typeof v) return args;
+        return [
+            v
+        ];
+    });
+    return {
+        command: list[0],
+        args: list.slice(1)
+    };
+}
+const constants_AGENTS = [
+    "npm",
+    "yarn",
+    "yarn@berry",
+    "pnpm",
+    "pnpm@6",
+    "bun",
+    "deno"
+];
+const LOCKS = {
+    "bun.lock": "bun",
+    "bun.lockb": "bun",
+    "deno.lock": "deno",
+    "pnpm-lock.yaml": "pnpm",
+    "pnpm-workspace.yaml": "pnpm",
+    "yarn.lock": "yarn",
+    "package-lock.json": "npm",
+    "npm-shrinkwrap.json": "npm"
+};
+const INSTALL_METADATA = {
+    "node_modules/.deno/": "deno",
+    "node_modules/.pnpm/": "pnpm",
+    "node_modules/.yarn-state.yml": "yarn",
+    "node_modules/.yarn_integrity": "yarn",
+    "node_modules/.package-lock.json": "npm",
+    ".pnp.cjs": "yarn",
+    ".pnp.js": "yarn",
+    "bun.lock": "bun",
+    "bun.lockb": "bun"
+};
+async function pathExists(path2, type) {
+    try {
+        const stat = await promises.stat(path2);
+        return "file" === type ? stat.isFile() : stat.isDirectory();
+    } catch  {
+        return false;
+    }
+}
+function* lookup(cwd = node_process.cwd()) {
+    let directory = node_path.resolve(cwd);
+    const { root } = node_path.parse(directory);
+    while(directory && directory !== root){
+        yield directory;
+        directory = node_path.dirname(directory);
+    }
+}
+async function parsePackageJson(filepath, options) {
+    if (!filepath || !await pathExists(filepath, "file")) return null;
+    return await handlePackageManager(filepath, options);
+}
+async function detect(options = {}) {
+    const { cwd, strategies = [
+        "lockfile",
+        "packageManager-field",
+        "devEngines-field"
+    ] } = options;
+    let stopDir;
+    if ("string" == typeof options.stopDir) {
+        const resolved = node_path.resolve(options.stopDir);
+        stopDir = (dir)=>dir === resolved;
+    } else stopDir = options.stopDir;
+    for (const directory of lookup(cwd)){
+        for (const strategy of strategies)switch(strategy){
+            case "lockfile":
+                for (const lock of Object.keys(LOCKS))if (await pathExists(node_path.join(directory, lock), "file")) {
+                    const name = LOCKS[lock];
+                    const result = await parsePackageJson(node_path.join(directory, "package.json"), options);
+                    if (result) return result;
+                    return {
+                        name,
+                        agent: name
+                    };
+                }
+                break;
+            case "packageManager-field":
+            case "devEngines-field":
+                {
+                    const result = await parsePackageJson(node_path.join(directory, "package.json"), options);
+                    if (result) return result;
+                    break;
+                }
+            case "install-metadata":
+                for (const metadata of Object.keys(INSTALL_METADATA)){
+                    const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+                    if (await pathExists(node_path.join(directory, metadata), fileOrDir)) {
+                        const name = INSTALL_METADATA[metadata];
+                        const agent = "yarn" === name ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+                        return {
+                            name,
+                            agent
+                        };
+                    }
+                }
+                break;
+        }
+        if (stopDir?.(directory)) break;
+    }
+    return null;
+}
+function getNameAndVer(pkg) {
+    const handelVer = (version)=>version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
+    if ("string" == typeof pkg.packageManager) {
+        const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+        return {
+            name,
+            ver: handelVer(ver)
+        };
+    }
+    if ("string" == typeof pkg.devEngines?.packageManager?.name) return {
+        name: pkg.devEngines.packageManager.name,
+        ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+}
+async function handlePackageManager(filepath, options) {
+    try {
+        const content = await promises.readFile(filepath, "utf8");
+        const pkg = options.packageJsonParser ? await options.packageJsonParser(content, filepath) : JSON.parse(content);
+        let agent;
+        const nameAndVer = getNameAndVer(pkg);
+        if (nameAndVer) {
+            const name = nameAndVer.name;
+            const ver = nameAndVer.ver;
+            let version = ver;
+            if ("yarn" === name && ver && Number.parseInt(ver) > 1) {
+                agent = "yarn@berry";
+                version = "berry";
+                return {
+                    name,
+                    agent,
+                    version
+                };
+            }
+            if ("pnpm" === name && ver && Number.parseInt(ver) < 7) {
+                agent = "pnpm@6";
+                return {
+                    name,
+                    agent,
+                    version
+                };
+            }
+            if (!constants_AGENTS.includes(name)) return options.onUnknown?.(pkg.packageManager) ?? null;
+            agent = name;
+            return {
+                name,
+                agent,
+                version
+            };
+        }
+    } catch  {}
+    return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+    return metadataPath.endsWith(".yarn_integrity");
+}
+function checkNodeVersion() {
+    const { versions } = process;
+    if ("styleText" in node_util || !versions.node || versions.bun || versions.deno) return;
+    throw new Error(`Unsupported Node.js version: "${process.versions.node || 'unknown'}". Expected Node.js >= 20.`);
+}
+checkNodeVersion();
+const createStyler = (style)=>(text)=>node_util.styleText(style, String(text));
+const color = {
+    dim: createStyler('dim'),
+    red: createStyler('red'),
+    bold: createStyler('bold'),
+    blue: createStyler('blue'),
+    cyan: createStyler('cyan'),
+    gray: createStyler('gray'),
+    black: createStyler('black'),
+    green: createStyler('green'),
+    white: createStyler('white'),
+    reset: createStyler('reset'),
+    yellow: createStyler('yellow'),
+    magenta: createStyler('magenta'),
+    underline: createStyler('underline'),
+    strikethrough: createStyler('strikethrough')
+};
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : node_process.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);
+}
+const { env: env } = node_process;
+let 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)) return;
+    if ('true' === env.FORCE_COLOR) return 1;
+    if ('false' === env.FORCE_COLOR) return 0;
+    if (0 === env.FORCE_COLOR.length) return 1;
+    const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    if (![
+        0,
+        1,
+        2,
+        3
+    ].includes(level)) return;
+    return level;
+}
+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' === node_process.platform) {
+        const osRelease = node_os.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',
+            'GITEA_ACTIONS',
+            'CIRCLECI'
+        ].some((key)=>key in env)) return 3;
+        if ([
+            'TRAVIS',
+            '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 ('xterm-ghostty' === env.TERM) return 3;
+    if ('wezterm' === 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);
+}
+const supportsColor = {
+    stdout: createSupportsColor({
+        isTTY: node_tty.isatty(1)
+    }),
+    stderr: createSupportsColor({
+        isTTY: node_tty.isatty(2)
+    })
+};
+const supports_color = supportsColor;
+const colorLevel = supports_color.stdout ? supports_color.stdout.level : 0;
+const errorStackRegExp = /at [^\r\n]{0,200}:\d+:\d+[\s\)]*$/;
+const anonymousErrorStackRegExp = /at [^\r\n]{0,200}\(<anonymous>\)$/;
+const indexErrorStackRegExp = /at [^\r\n]{0,200}\(index\s\d+\)$/;
+const isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message) || indexErrorStackRegExp.test(message);
+const startColor = [
+    189,
+    255,
+    243
+];
+const endColor = [
+    74,
+    194,
+    154
+];
+const isWord = (char)=>!/[\s\n]/.test(char);
+const gradient = (message)=>{
+    if (colorLevel < 3) return 2 === colorLevel ? color.cyan(message) : message;
+    const chars = [
+        ...message
+    ];
+    const steps = chars.filter(isWord).length;
+    let r = startColor[0];
+    let g = startColor[1];
+    let b = startColor[2];
+    const rStep = (endColor[0] - r) / steps;
+    const gStep = (endColor[1] - g) / steps;
+    const bStep = (endColor[2] - b) / steps;
+    let output = '';
+    for (const 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 color.bold(output);
+};
+const LOG_LEVEL = {
+    silent: -1,
+    error: 0,
+    warn: 1,
+    info: 2,
+    log: 2,
+    verbose: 3
+};
+const LOG_TYPES = {
+    error: {
+        label: 'error',
+        level: 'error',
+        color: color.red
+    },
+    warn: {
+        label: 'warn',
+        level: 'warn',
+        color: color.yellow
+    },
+    info: {
+        label: 'info',
+        level: 'info',
+        color: color.cyan
+    },
+    start: {
+        label: 'start',
+        level: 'info',
+        color: color.cyan
+    },
+    ready: {
+        label: 'ready',
+        level: 'info',
+        color: color.green
+    },
+    success: {
+        label: 'success',
+        level: 'info',
+        color: color.green
+    },
+    log: {
+        level: 'info'
+    },
+    debug: {
+        label: 'debug',
+        level: 'verbose',
+        color: color.magenta
+    }
+};
+const normalizeErrorMessage = (err)=>{
+    if (err.stack) {
+        const [rawName, ...rest] = err.stack.split('\n');
+        const name = rawName.startsWith('Error: ') ? rawName.slice(7) : rawName;
+        return `${name}\n${color.gray(rest.join('\n'))}`;
+    }
+    return err.message;
+};
+const createLogger = (options = {})=>{
+    const { level = 'info', prefix, console: console1 = globalThis.console } = options;
+    let maxLevel = level;
+    const log = (type, message, ...args)=>{
+        const logType = LOG_TYPES[type];
+        const { level } = logType;
+        if (LOG_LEVEL[level] > LOG_LEVEL[maxLevel]) return;
+        if (null == message) return console1.log();
+        let label = '';
+        let text = '';
+        if ('label' in logType) {
+            label = (logType.label || '').padEnd(7);
+            label = color.bold(logType.color ? logType.color(label) : label);
+        }
+        if (message instanceof Error) {
+            text += normalizeErrorMessage(message);
+            const { cause } = message;
+            if (cause) {
+                text += color.yellow('\n  [cause]: ');
+                text += cause instanceof Error ? normalizeErrorMessage(cause) : String(cause);
+            }
+        } else if ('error' === level && 'string' == typeof message) {
+            const lines = message.split('\n');
+            text = lines.map((line)=>isErrorStackMessage(line) ? color.gray(line) : line).join('\n');
+        } else text = `${message}`;
+        if (prefix) text = `${prefix} ${text}`;
+        const method = 'error' === level || 'warn' === level ? level : 'log';
+        console1[method](label.length ? `${label} ${text}` : text, ...args);
+    };
+    const logger = {
+        greet: (message)=>log('log', gradient(message))
+    };
+    Object.keys(LOG_TYPES).forEach((key)=>{
+        logger[key] = (...args)=>log(key, ...args);
+    });
+    Object.defineProperty(logger, 'level', {
+        get: ()=>maxLevel,
+        set (val) {
+            maxLevel = val;
+        }
+    });
+    Object.defineProperty(logger, 'options', {
+        get: ()=>({
+                ...options
+            })
+    });
+    logger.override = (customLogger)=>{
+        Object.assign(logger, customLogger);
+    };
+    return logger;
+};
+createLogger();
+const cross_spawn = __webpack_require__("../../node_modules/cross-spawn/index.js");
+const lib = __webpack_require__("../../node_modules/@babel/code-frame/lib/index.js");
+const LAZY_COMPILATION_IDENTIFIER = 'lazy-compilation-proxy';
+const isVerbose = (targetLogger)=>'verbose' === targetLogger.level;
+const removeLoaderChainDelimiter = (moduleId, logger)=>{
+    if (isVerbose(logger)) return moduleId;
+    const LOADER_CHAIN_SEPARATOR = '!=!';
+    return moduleId.split(LOADER_CHAIN_SEPARATOR)[0];
+};
+const formatFileName = (fileName, stats, root)=>{
+    if (!fileName) return '';
+    const DATA_URI_PREFIX = "data:text/javascript,";
+    if (fileName.startsWith(DATA_URI_PREFIX)) {
+        let snippet = fileName.replace(DATA_URI_PREFIX, '');
+        if (snippet.length > 30) snippet = `${snippet.slice(0, 30)}...`;
+        return `File: ${color.cyan('data-uri virtual module')} ${color.dim(`(${snippet})`)}\n`;
+    }
+    const prefix = root + sep;
+    if (fileName.startsWith(prefix)) fileName = fileName.replace(prefix, `.${sep}`);
+    if (/:\d+:\d+/.test(fileName)) return `File: ${color.cyan(fileName)}\n`;
+    if (stats.loc) return `File: ${color.cyan(`${fileName}:${stats.loc}`)}\n`;
+    return `File: ${color.cyan(`${fileName}:1:1`)}\n`;
+};
+function resolveFileName(stats, logger) {
+    const file = stats.file || stats.moduleName;
+    if (file) return removeLoaderChainDelimiter(file, logger);
+    if (stats.moduleIdentifier) {
+        const regex = /(?:!|^)([^!]+)$/;
+        const matched = stats.moduleIdentifier.match(regex);
+        if (matched) {
+            const fileName = matched.pop();
+            if (fileName) return removeLoaderChainDelimiter(fileName, logger);
+        }
+    }
+    return '';
+}
+function formatModuleTrace(stats, errorFile, level, logger) {
+    if (!stats.moduleTrace) return;
+    const moduleNames = stats.moduleTrace.map((trace)=>trace.originName && removeLoaderChainDelimiter(trace.originName, logger)).filter((trace)=>trace && !trace.startsWith(LAZY_COMPILATION_IDENTIFIER));
+    if (!moduleNames.length) return;
+    if (errorFile) {
+        const formatted = removeLoaderChainDelimiter(errorFile, logger);
+        if (moduleNames[0] !== formatted) moduleNames.unshift(formatted);
+    }
+    let trace = moduleNames.slice().reverse();
+    const MAX = 4;
+    if (trace.length > MAX && !isVerbose(logger)) {
+        const HEAD = 2;
+        const TAIL = 2;
+        trace = [
+            ...trace.slice(0, HEAD),
+            `… (${trace.length - HEAD - TAIL} hidden)`,
+            ...trace.slice(trace.length - TAIL)
+        ];
+    }
+    return color.dim(`Import traces (entry → ${level}):\n  ${trace.join('\n  ')} ${color.bold(color.red('×'))}`);
+}
+function hintUnknownFiles(message) {
+    const hint = 'You may need an appropriate loader to handle this file type.';
+    if (-1 === message.indexOf(hint)) return message;
+    const createPluginHint = (packageName, keyword)=>`To enable support for ${keyword}, use "${color.yellow(`@rsbuild/plugin-${packageName}`)}" ${color.dim(`(https://npmjs.com/package/@rsbuild/plugin-${packageName})`)}.\n`;
+    const recommendPlugins = [
+        {
+            test: /File: .+\.s(c|a)ss/,
+            hint: createPluginHint('sass', 'Sass')
+        },
+        {
+            test: /File: .+\.less/,
+            hint: createPluginHint('less', 'Less')
+        },
+        {
+            test: /File: .+\.styl(us)?/,
+            hint: createPluginHint('stylus', 'Stylus')
+        },
+        {
+            test: /File: .+\.vue?/,
+            hint: createPluginHint('vue', 'Vue')
+        },
+        {
+            test: /File: .+\.svelte?/,
+            hint: createPluginHint('svelte', 'Svelte')
+        },
+        {
+            test: /File: .+\.mdx/,
+            hint: createPluginHint('mdx', 'MDX')
+        },
+        {
+            test: /File: .+\.toml/,
+            hint: createPluginHint('toml', 'TOML')
+        },
+        {
+            test: /File: .+\.yaml/,
+            hint: createPluginHint('yaml', 'YAML')
+        }
+    ];
+    for (const plugin of recommendPlugins)if (plugin.test.test(message)) return message.replace(hint, plugin.hint);
+    return message;
+}
+const hintAssetsConflict = (message)=>{
+    const hint = 'Multiple assets emit different content to the same filename';
+    if (-1 === message.indexOf(hint)) return message;
+    const extraMessage = `You may need to adjust ${color.yellow('output.filename')} configuration to prevent name conflicts. (See ${color.yellow('https://rsbuild.rs/config/output/filename')})`;
+    return `${message}\n${extraMessage}`;
+};
+const hintNodePolyfill = (message)=>{
+    const getTips = (moduleName)=>{
+        const tips = [
+            `Error: "${moduleName}" is a built-in Node.js module and cannot be imported in client-side code.\n`,
+            'Solution: Check if you need to import Node.js module.',
+            '  - If not needed, remove the import.',
+            `  - If needed, use "${color.yellow('@rsbuild/plugin-node-polyfill')}" to polyfill it. (See ${color.yellow('https://npmjs.com/package/@rsbuild/plugin-node-polyfill')})`
+        ];
+        return `${message}\n\n${color.red(tips.join('\n'))}`;
+    };
+    const isNodeProtocolError = message.includes('need an additional plugin to handle "node:" URIs');
+    if (isNodeProtocolError) return getTips('node:*');
+    if (!message.includes("Can't resolve")) return message;
+    const matchArray = stripVTControlCharacters(message).match(/Can't resolve '(\w+)'/);
+    if (!matchArray) return message;
+    const moduleName = matchArray[1];
+    if (moduleName && builtinModules.includes(moduleName)) return getTips(moduleName);
+    return message;
+};
+function format_formatStatsError(stats, root, level = 'error', logger) {
+    const fileName = resolveFileName(stats, logger);
+    let message = `${formatFileName(fileName, stats, root)}${stats.message}`;
+    const verbose = isVerbose(logger);
+    if (verbose) {
+        if (stats.details) message += `\nDetails: ${stats.details}\n`;
+        if (stats.stack) message += `\n${stats.stack}`;
+    }
+    if ('error' === level || isVerbose(logger)) {
+        const moduleTrace = formatModuleTrace(stats, fileName, level, logger);
+        if (moduleTrace) message += moduleTrace;
+    }
+    const innerError = '-- inner error --';
+    if (!verbose && message.includes(innerError)) message = message.split(innerError)[0];
+    message = hintUnknownFiles(message);
+    message = hintNodePolyfill(message);
+    message = hintAssetsConflict(message);
+    let lines = message.split('\n');
+    lines = lines.filter((line, index, arr)=>0 === index || '' !== line.trim() || line.trim() !== arr[index - 1].trim());
+    message = lines.join('\n');
+    return message.trim();
+}
+const styles = {
+    1: 'font-weight:bold',
+    2: 'opacity:0.5',
+    3: 'font-style:italic',
+    4: 'text-decoration:underline;text-underline-offset:3px',
+    8: 'display:none',
+    9: 'text-decoration:line-through',
+    30: 'color:#000',
+    31: 'color:#fb6a6a',
+    32: 'color:#6ef790',
+    33: 'color:#eff986',
+    34: 'color:#6eb2f7',
+    35: 'color:#f76ebe',
+    36: 'color:#6eecf7',
+    37: 'color:#f0f0f0',
+    90: 'color:#888'
+};
+for(let i = 91; i <= 97; i++)styles[i] = styles[i - 60];
+const closeCode = [
+    0,
+    21,
+    22,
+    23,
+    24,
+    27,
+    28,
+    29,
+    39,
+    49
+];
+function ansiHTML(text) {
+    const ansiCodes = [];
+    let ret = text.replace(/\x1B\[([0-9;]+)m/g, (_match, sequences)=>{
+        let style = '';
+        for (const seq of sequences.split(';'))if (styles[seq]) style += `${styles[seq]};`;
+        if (style) {
+            ansiCodes.push(sequences);
+            return `<span style="${style}">`;
+        }
+        if (closeCode.includes(Number(sequences)) && ansiCodes.length > 0) {
+            ansiCodes.pop();
+            return '</span>';
+        }
+        return '';
+    });
+    if (ansiCodes.length > 0) ret += Array(ansiCodes.length + 1).join('</span>');
+    return ret;
+}
+const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
+function toRelativePath(base, filepath) {
+    const relativePath = relative(base, filepath);
+    if ('' === relativePath) return `.${sep}`;
+    if (!relativePath.startsWith('.')) return `.${sep}${relativePath}`;
+    return relativePath;
+}
+function escapeHtml(text) {
+    if (!text) return '';
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+function formatDisplayPath(filePath, isAbsolute, root) {
+    if (NODE_MODULES_REGEX.test(filePath)) for (const needle of [
+        '/node_modules/',
+        '\\node_modules\\'
+    ]){
+        const index = filePath.lastIndexOf(needle);
+        if (-1 !== index) return filePath.slice(index + 1);
+    }
+    if (root && isAbsolute) return toRelativePath(root, filePath);
+    return filePath;
+}
+function convertLinksInHtml(text, root) {
+    const PATH_RE = /(?:\.\.?[/\\]|(file:\/\/\/)?[a-zA-Z]:\\|(file:\/\/)?\/|[A-Za-z0-9._-]+[/\\])[^\s:]*:\d+:\d+/g;
+    const URL_RE = /(https?:\/\/(?:[\w-]+\.)+[a-z0-9](?:[\w-.~:/?#[\]@!$&'*+,;=])*)/gi;
+    const NODE_INTERNAL_RE = /node:internal[/\\]/;
+    const RSPACK_RUNTIME_RE = /webpack\/runtime\//;
+    const FILE_URI_WINDOWS_RE = /^file:\/\/\/([A-Za-z]:)/;
+    const FILE_URI_UNIX_RE = /^file:\/\//;
+    const stripFileUri = (file)=>{
+        if (!file.startsWith('file://')) return file;
+        const windows = file.replace(FILE_URI_WINDOWS_RE, '$1');
+        if (windows !== file) return windows;
+        return file.replace(FILE_URI_UNIX_RE, '');
+    };
+    const lines = text.split('\n');
+    const replacedLines = lines.map((line)=>{
+        if (NODE_INTERNAL_RE.test(line) || RSPACK_RUNTIME_RE.test(line)) return line;
+        let replacedLine = line.replace(PATH_RE, (file)=>{
+            file = stripFileUri(file);
+            const hasClosingSpan = file.includes('</span>') && !file.includes('<span');
+            const filePath = hasClosingSpan ? file.replace('</span>', '') : file;
+            const suffix = hasClosingSpan ? '</span>' : '';
+            const isAbsolute = node_path.isAbsolute(filePath);
+            const absolutePath = root && !isAbsolute ? node_path.join(root, filePath) : filePath;
+            const displayPath = formatDisplayPath(filePath, isAbsolute, root);
+            return `<a class="file-link" data-file="${absolutePath}">${displayPath}</a>${suffix}`;
+        });
+        replacedLine = replacedLine.replace(URL_RE, (url)=>`<a class="url-link" href="${url}" target="_blank" rel="noopener noreferrer">${url}</a>`);
+        return replacedLine;
+    });
+    return replacedLines.join('\n');
+}
+function renderErrorToHtml(error, root) {
+    return convertLinksInHtml(ansiHTML(escapeHtml(error)), root);
+}
+function getServerMessageErrors(errors, context) {
+    const { rootPath, logger, overlay } = context;
+    const formattedErrors = errors.map((item)=>format_formatStatsError(item, rootPath, 'error', logger));
+    let overlayErrors = formattedErrors;
+    if (overlay && 'object' == typeof overlay && 'function' == typeof overlay.errors) {
+        const { errors: filter } = overlay;
+        overlayErrors = formattedErrors.filter((error)=>filter(new Error(error)));
+    }
+    const html = overlayErrors.map((error)=>renderErrorToHtml(error, rootPath)).join('\n\n').trim();
+    return {
+        type: 'errors',
+        data: {
+            text: formattedErrors,
+            html
+        }
+    };
+}
+const DEBOUNCE_MS = 500;
+const resolveAbsolutePath = (p)=>node_path.isAbsolute(p) ? p : node_path.join(process.cwd(), p);
+const dist_env = process.env;
+const runChild = ({ cmd, args, cwd, logger, shouldFail, buffered, formatter, executeName })=>new Promise((resolve, reject)=>{
+        const bufferedOutput = [];
+        const child = (0, cross_spawn.spawn)(cmd, args, {
+            cwd,
+            env: {
+                ...dist_env,
+                FORCE_COLOR: '1'
+            },
+            shell: false,
+            stdio: 'pipe'
+        });
+        const emit = (data, log)=>{
+            const trimmed = data.toString().trimEnd();
+            if (!trimmed) return;
+            if (buffered) bufferedOutput.push(trimmed);
+            else log(trimmed);
+        };
+        child.stdout?.on('data', (d)=>emit(d, (s)=>logger?.info(s)));
+        child.stderr?.on('data', (d)=>emit(d, (s)=>logger?.error(s)));
+        child.on('error', (error)=>{
+            if (buffered) return void resolve({
+                status: 'fallback'
+            });
+            logger?.error(`${executeName} Error: ${error.message}`);
+            reject(error);
+        });
+        child.on('exit', (code)=>{
+            const output = bufferedOutput.join('\n');
+            if (0 === code) {
+                if (!buffered) logger?.info(`${executeName} successfully finished.`);
+                const errors = formatter(output);
+                resolve({
+                    status: 'lint-errors',
+                    errors
+                });
+            } else if (1 === code) {
+                const errors = formatter(output);
+                if (errors.length > 0) resolve({
+                    status: 'lint-errors',
+                    errors
+                });
+                else {
+                    if (buffered) {
+                        const errors = bufferedOutput.flatMap((line)=>formatter(line));
+                        resolve({
+                            status: 'lint-errors',
+                            errors
+                        });
+                    }
+                    if (shouldFail) reject(new Error(`${executeName} found lint errors.`));
+                    else resolve({
+                        status: 'lint-errors',
+                        errors: []
+                    });
+                }
+            } else if (buffered) resolve({
+                status: 'fallback'
+            });
+            else {
+                logger?.error(`${executeName} exited with unexpected code: ${code}`);
+                resolve({
+                    status: 'ok'
+                });
+            }
+        });
+    });
+const runLintOnce = async (options, logger, pmPromise)=>{
+    const { path = '', lintPath = '', executeName, args = [], shouldFail = false, formatter } = options;
+    const cwd = resolveAbsolutePath(path);
+    const pm = await pmPromise;
+    if (!pm) throw new Error('Could not detect package manager');
+    const tryRun = async (useExecuteLocal)=>{
+        const resolved = lintPath ? {
+            args,
+            command: resolveAbsolutePath(lintPath)
+        } : resolveCommand(pm.agent, useExecuteLocal ? 'execute-local' : 'execute', [
+            executeName,
+            ...args
+        ]);
+        if (!resolved) {
+            if (useExecuteLocal && !lintPath) return tryRun(false);
+            throw new Error(`${executeName} Could not resolve ${executeName} command for ${pm.agent}`);
+        }
+        const result = await runChild({
+            args: resolved.args,
+            buffered: useExecuteLocal && !lintPath,
+            cmd: resolved.command,
+            cwd,
+            logger,
+            shouldFail,
+            formatter,
+            executeName
+        });
+        if ('fallback' === result.status) return tryRun(false);
+        return result;
+    };
+    return tryRun(true);
+};
+const lintPlugin = (options)=>({
+        setup (api) {
+            const executeName = options.executeName;
+            let timeoutId;
+            let pmPromise;
+            const logger = api.logger;
+            let send;
+            let lastCompilation = null;
+            const lintResults = {
+                error: [],
+                warning: []
+            };
+            let overlay = true;
+            const getPm = ()=>{
+                if (!pmPromise) pmPromise = detect();
+                return pmPromise;
+            };
+            const sendErrorToOverlay = (errors)=>{
+                if (0 === errors.length) return;
+                try {
+                    if (!send || 'function' != typeof send) return void logger?.warn('sockWrite not available, cannot send errors to overlay');
+                    const lastResult = (lastCompilation?.errors ?? []).filter((item)=>!item.message.trimStart().startsWith(`× [${executeName}]`));
+                    const issues = [
+                        ...lastResult.map((item)=>({
+                                ...item,
+                                loc: item.loc ? 'name' in item.loc ? item.loc : `${item.loc.start.line}:${item.loc.start.column}` : void 0
+                            })),
+                        ...errors.map((e)=>formateCodeFrame(e)).map((item)=>({
+                                ...item,
+                                loc: item.loc ? `${item.loc.start.line}:${item.loc.start.column}` : void 0
+                            }))
+                    ];
+                    send('errors', getServerMessageErrors(issues, {
+                        rootPath: api.context.rootPath,
+                        logger: logger,
+                        overlay
+                    }).data);
+                    logger?.info(`Sent ${errors.length} lint errors to overlay`);
+                } catch (e) {
+                    logger?.error(`Failed to send error to overlay: ${e}`);
+                }
+            };
+            const clearOverlay = ()=>{
+                try {
+                    if (!send || 'function' != typeof send) return;
+                    send('errors', {
+                        html: '',
+                        text: []
+                    });
+                } catch (e) {
+                    logger?.error(`${executeName} Failed to clear overlay: ${e}`);
+                }
+            };
+            let runId = 0;
+            const runLint = async ()=>{
+                try {
+                    const currentRun = ++runId;
+                    const result = await runLintOnce(options, logger, getPm());
+                    if (currentRun !== runId) return;
+                    if ('lint-errors' === result.status) {
+                        lintResults.error = result.errors;
+                        sendErrorToOverlay(lintResults.error);
+                    } else clearOverlay();
+                } catch (error) {
+                    logger?.error(`${executeName} Error executing ${executeName}: ${error}`);
+                }
+            };
+            const debouncedRun = ()=>{
+                if (timeoutId) clearTimeout(timeoutId);
+                timeoutId = setTimeout(()=>runLint(), DEBOUNCE_MS);
+            };
+            const formateCodeFrame = (item)=>{
+                const source = item.file && __rspack_external_node_fs_5ea92f0c.existsSync(item.file) && __rspack_external_node_fs_5ea92f0c.readFileSync(item.file, 'utf-8');
+                let frame = '';
+                if (source && item.loc) frame = (0, lib.gl)(source, item.loc, {
+                    highlightCode: true
+                }).split('\n').map((line)=>`  ${line}`).join(__rspack_external_node_os_74b4b876.EOL);
+                return {
+                    ...item,
+                    message: `[${executeName}] [${item.code}] ${item.message} ${item.help} \n${frame}`
+                };
+            };
+            api.modifyRspackConfig((config)=>{
+                config.plugins = config.plugins ?? [];
+                config.plugins.push({
+                    apply (compiler) {
+                        compiler.hooks.thisCompilation.tap(`${executeName}-plugin`, (compilation)=>{
+                            try {
+                                compilation.errors.push(...lintResults.error.map((item)=>formateCodeFrame(item)));
+                                compilation.warnings.push(...lintResults.warning.map((w)=>formateCodeFrame(w)));
+                                lastCompilation = compilation;
+                            } catch (e) {
+                                console.error(e);
+                            }
+                        });
+                    }
+                });
+            });
+            api.modifyRsbuildConfig((config)=>{
+                config.server = config.server ?? {};
+                config.plugins = config.plugins ?? [];
+                overlay = config.dev?.client?.overlay ?? true;
+                const setup = config.server.setup ?? [];
+                const _setup = (context)=>{
+                    if ('dev' === context.action) {
+                        const devServer = context.server;
+                        send = devServer.sockWrite;
+                        devServer.httpServer?.on('upgrade', (req)=>{
+                            if (req.url?.includes(config.dev?.client?.path)) setTimeout(()=>{
+                                sendErrorToOverlay(lintResults.error);
+                            }, 500);
+                        });
+                    }
+                };
+                if (Array.isArray(setup)) config.server.setup = [
+                    _setup,
+                    ...setup
+                ];
+                else config.server.setup = (context)=>{
+                    _setup(context);
+                    return setup(context);
+                };
+            });
+            api.onAfterDevCompile(()=>{
+                debouncedRun();
+            });
+            api.onAfterStartDevServer(async ()=>{
+                const { lintOnStart = true } = options;
+                if (lintOnStart) await runLint();
+            });
+        },
+        name: 'lint-plugin'
+    });
+const src = lintPlugin;
+const dist = src;
+const parse = (output)=>{
+    try {
+        const out = JSON.parse(output);
+        if (out.diagnostics) if (Array.isArray(out.diagnostics)) return out.diagnostics;
+        else return [
+            out.diagnostics
+        ];
+        return [];
+    } catch (e) {
+        return [];
+    }
+};
+const src_formatter = (output)=>{
+    const issues = parse(output);
+    return issues.map((item)=>({
+            ...item,
+            severity: 'error',
+            name: '',
+            message: item.message,
+            file: item.location.path,
+            loc: item.location.range,
+            code: item.code.url,
+            help: (item.suggestions || [])?.map((s)=>s.text).join('\n')
+        }));
+};
+const src_resolveAbsolutePath = (p)=>node_path.isAbsolute(p) ? p : node_path.join(process.cwd(), p);
+const buildArgs = (options)=>{
+    const { configFile = '', colors, useServer, verbose, maxDiagnostics, skipParseErrors, noErrorsOnUnmatched, errorOnWarnings, diagnosticLevel } = options;
+    const args = [
+        'lint'
+    ];
+    if (colors) args.push("--colors", `${colors}`);
+    if (useServer) args.push("--use-server", `${useServer}`);
+    if (verbose) args.push("--verbose", `${verbose}`);
+    if (maxDiagnostics) args.push("--max-diagnostics", `${maxDiagnostics}`);
+    if (skipParseErrors) args.push("--skip-parse-errors", `${skipParseErrors}`);
+    if (noErrorsOnUnmatched) args.push("--no-errors-on-unmatched", `${noErrorsOnUnmatched}`);
+    if (errorOnWarnings) args.push("--error-on-warnings", `${errorOnWarnings}`);
+    if (diagnosticLevel) args.push("--diagnostic-level", diagnosticLevel);
+    if (configFile) {
+        const configFilePath = src_resolveAbsolutePath(configFile);
+        if (existsSync(configFilePath)) args.push('-config-path', configFilePath);
+    }
+    return args;
+};
+const linterPlugin = (options = {})=>({
+        setup (api) {
+            dist({
+                path: options.path,
+                shouldFail: options.failOnError || options.failOnWarning,
+                args: [
+                    ...buildArgs(options),
+                    '--reporter',
+                    'rdjson'
+                ],
+                lintPath: options.linterPath,
+                executeName: 'biome',
+                formatter: src_formatter
+            }).setup(api);
+        },
+        name: 'biome-plugin'
+    });
+const src_0 = linterPlugin;
+export default src_0;
+export { linterPlugin };