@unpackjs/core 4.6.1 → 4.7.1

package/dist/index.js

@@ -1,10 +1,14 @@
-let lastTrackTime, lastFileInfo, logger;
+/*! For license information please see index.js.LICENSE.txt */
+let lastTrackTime, devServerPort, lastFileInfo, logger;
 import __rslib_shim_module__ from "node:module";
 let require = __rslib_shim_module__.createRequire(import.meta.url);
 import { fileURLToPath as __rspack_fileURLToPath, pathToFileURL } from "node:url";
 import node_path, { dirname as __rspack_dirname, join, sep } from "node:path";
-import * as __rspack_external__compiled_launch_editor_index_js_29002383 from "../compiled/launch-editor/index.js";
-import * as __rspack_external__compiled_webpack_merge_index_js_efd91626 from "../compiled/webpack-merge/index.js";
+import * as __rspack_external_child_process from "child_process";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_os from "os";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_url from "url";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { Compilation, rspack } from "@rspack/core";
 import cac from "cac";
@@ -24,11 +28,1105 @@ import { RspackDevServer } from "@rspack/dev-server";
 import { exec, spawn } from "node:child_process";
 import chokidar from "chokidar";
 __webpack_require__.add({
-    "compiled/launch-editor" (module) {
-        module.exports = __rspack_external__compiled_launch_editor_index_js_29002383;
+    "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let clone = __webpack_require__("../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js"), typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"), isPlainObject = __webpack_require__("../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js");
+        module.exports = function cloneDeep(val, instanceClone) {
+            switch(typeOf(val)){
+                case 'object':
+                    var val1 = val, instanceClone1 = instanceClone;
+                    if ('function' == typeof instanceClone1) return instanceClone1(val1);
+                    if (instanceClone1 || isPlainObject(val1)) {
+                        let res = new val1.constructor();
+                        for(let key in val1)res[key] = cloneDeep(val1[key], instanceClone1);
+                        return res;
+                    }
+                    return val1;
+                case 'array':
+                    var val2 = val, instanceClone2 = instanceClone;
+                    let res = new val2.constructor(val2.length);
+                    for(let i = 0; i < val2.length; i++)res[i] = cloneDeep(val2[i], instanceClone2);
+                    return res;
+                default:
+                    return clone(val);
+            }
+        };
+    },
+    "../../node_modules/.pnpm/flat@5.0.2/node_modules/flat/index.js" (module) {
+        function isBuffer(obj) {
+            return obj && obj.constructor && 'function' == typeof obj.constructor.isBuffer && obj.constructor.isBuffer(obj);
+        }
+        function keyIdentity(key) {
+            return key;
+        }
+        function flatten(target, opts) {
+            let delimiter = (opts = opts || {}).delimiter || '.', maxDepth = opts.maxDepth, transformKey = opts.transformKey || keyIdentity, output = {};
+            return !function step(object, prev, currentDepth) {
+                currentDepth = currentDepth || 1, Object.keys(object).forEach(function(key) {
+                    let value = object[key], isarray = opts.safe && Array.isArray(value), type = Object.prototype.toString.call(value), isbuffer = isBuffer(value), newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+                    if (!isarray && !isbuffer && ('[object Object]' === type || '[object Array]' === type) && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+                    output[newKey] = value;
+                });
+            }(target), output;
+        }
+        module.exports = flatten, flatten.flatten = flatten, flatten.unflatten = function unflatten(target, opts) {
+            let delimiter = (opts = opts || {}).delimiter || '.', overwrite = opts.overwrite || !1, transformKey = opts.transformKey || keyIdentity, result = {};
+            if (isBuffer(target) || '[object Object]' !== Object.prototype.toString.call(target)) return target;
+            function getkey(key) {
+                let parsedKey = Number(key);
+                return isNaN(parsedKey) || -1 !== key.indexOf('.') || opts.object ? key : parsedKey;
+            }
+            return Object.keys(target = Object.keys(target).reduce(function(result, key) {
+                var target1, val;
+                let type, type1 = Object.prototype.toString.call(target[key]);
+                return ('[object Object]' === type1 || '[object Array]' === type1) && (val = target[key], type = Object.prototype.toString.call(val), val && ('[object Array]' === type ? val.length : '[object Object]' === type ? Object.keys(val).length : !void 0)) ? Object.keys(target1 = flatten(target[key], opts)).reduce(function(result, key1) {
+                    return result[key + delimiter + key1] = target1[key1], result;
+                }, result) : (result[key] = target[key], result);
+            }, {})).forEach(function(key) {
+                let split = key.split(delimiter).map(transformKey), key1 = getkey(split.shift()), key2 = getkey(split[0]), recipient = result;
+                for(; void 0 !== key2;){
+                    if ('__proto__' === key1) return;
+                    let type = Object.prototype.toString.call(recipient[key1]), isobject = '[object Object]' === type || '[object Array]' === type;
+                    if (!overwrite && !isobject && void 0 !== recipient[key1]) return;
+                    (!overwrite || isobject) && (overwrite || null != recipient[key1]) || (recipient[key1] = 'number' != typeof key2 || opts.object ? {} : []), recipient = recipient[key1], split.length > 0 && (key1 = getkey(split.shift()), key2 = getkey(split[0]));
+                }
+                recipient[key1] = unflatten(target[key], opts);
+            }), result;
+        };
+    },
+    "../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var isObject = __webpack_require__("../../node_modules/.pnpm/isobject@3.0.1/node_modules/isobject/index.js");
+        function isObjectObject(o) {
+            return !0 === isObject(o) && '[object Object]' === Object.prototype.toString.call(o);
+        }
+        module.exports = function(o) {
+            var ctor, prot;
+            return !1 !== isObjectObject(o) && 'function' == typeof (ctor = o.constructor) && !1 !== isObjectObject(prot = ctor.prototype) && !1 !== prot.hasOwnProperty('isPrototypeOf');
+        };
+    },
+    "../../node_modules/.pnpm/isobject@3.0.1/node_modules/isobject/index.js" (module) {
+        module.exports = function(val) {
+            return null != val && 'object' == typeof val && !1 === Array.isArray(val);
+        };
+    },
+    "../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js" (module) {
+        var toString = Object.prototype.toString;
+        function ctorName(val) {
+            return 'function' == typeof val.constructor ? val.constructor.name : null;
+        }
+        module.exports = function(val) {
+            if (void 0 === val) return 'undefined';
+            if (null === val) return 'null';
+            var val1, val2, val3, val4, val5, val6, type = typeof val;
+            if ('boolean' === type) return 'boolean';
+            if ('string' === type) return 'string';
+            if ('number' === type) return 'number';
+            if ('symbol' === type) return 'symbol';
+            if ('function' === type) return 'GeneratorFunction' === ctorName(val) ? 'generatorfunction' : 'function';
+            if (val1 = val, Array.isArray ? Array.isArray(val1) : val1 instanceof Array) return 'array';
+            if ((val2 = val).constructor && 'function' == typeof val2.constructor.isBuffer && val2.constructor.isBuffer(val2)) return 'buffer';
+            if (function(val) {
+                try {
+                    if ('number' == typeof val.length && 'function' == typeof val.callee) return !0;
+                } catch (err) {
+                    if (-1 !== err.message.indexOf('callee')) return !0;
+                }
+                return !1;
+            }(val)) return 'arguments';
+            if ((val3 = val) instanceof Date || 'function' == typeof val3.toDateString && 'function' == typeof val3.getDate && 'function' == typeof val3.setDate) return 'date';
+            if ((val4 = val) instanceof Error || 'string' == typeof val4.message && val4.constructor && 'number' == typeof val4.constructor.stackTraceLimit) return 'error';
+            if ((val5 = val) instanceof RegExp || 'string' == typeof val5.flags && 'boolean' == typeof val5.ignoreCase && 'boolean' == typeof val5.multiline && 'boolean' == typeof val5.global) return 'regexp';
+            switch(ctorName(val)){
+                case 'Symbol':
+                    return 'symbol';
+                case 'Promise':
+                    return 'promise';
+                case 'WeakMap':
+                    return 'weakmap';
+                case 'WeakSet':
+                    return 'weakset';
+                case 'Map':
+                    return 'map';
+                case 'Set':
+                    return 'set';
+                case 'Int8Array':
+                    return 'int8array';
+                case 'Uint8Array':
+                    return 'uint8array';
+                case 'Uint8ClampedArray':
+                    return 'uint8clampedarray';
+                case 'Int16Array':
+                    return 'int16array';
+                case 'Uint16Array':
+                    return 'uint16array';
+                case 'Int32Array':
+                    return 'int32array';
+                case 'Uint32Array':
+                    return 'uint32array';
+                case 'Float32Array':
+                    return 'float32array';
+                case 'Float64Array':
+                    return 'float64array';
+            }
+            if ('function' == typeof (val6 = val).throw && 'function' == typeof val6.return && 'function' == typeof val6.next) return 'generator';
+            switch(type = toString.call(val)){
+                case '[object Object]':
+                    return 'object';
+                case '[object Map Iterator]':
+                    return 'mapiterator';
+                case '[object Set Iterator]':
+                    return 'setiterator';
+                case '[object String Iterator]':
+                    return 'stringiterator';
+                case '[object Array Iterator]':
+                    return 'arrayiterator';
+            }
+            return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
+        };
+    },
+    "../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/editor-info/linux.js" (module) {
+        module.exports = {
+            atom: 'atom',
+            Brackets: 'brackets',
+            'code-insiders': 'code-insiders',
+            code: 'code',
+            vscodium: 'vscodium',
+            codium: 'codium',
+            cursor: 'cursor',
+            trae: 'trae',
+            antigravity: 'antigravity',
+            emacs: 'emacs',
+            gvim: 'gvim',
+            idea: 'idea',
+            'idea.sh': 'idea',
+            phpstorm: 'phpstorm',
+            'phpstorm.sh': 'phpstorm',
+            pycharm: 'pycharm',
+            'pycharm.sh': 'pycharm',
+            rubymine: 'rubymine',
+            'rubymine.sh': 'rubymine',
+            sublime_text: 'subl',
+            vim: 'vim',
+            webstorm: 'webstorm',
+            'webstorm.sh': 'webstorm',
+            goland: 'goland',
+            'goland.sh': 'goland',
+            rider: 'rider',
+            'rider.sh': 'rider',
+            zed: 'zed'
+        };
+    },
+    "../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/editor-info/macos.js" (module) {
+        module.exports = {
+            '/Applications/Atom.app/Contents/MacOS/Atom': 'atom',
+            '/Applications/Atom Beta.app/Contents/MacOS/Atom Beta': '/Applications/Atom Beta.app/Contents/MacOS/Atom Beta',
+            '/Applications/Brackets.app/Contents/MacOS/Brackets': 'brackets',
+            '/Applications/Sublime Text.app/Contents/MacOS/Sublime Text': '/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl',
+            '/Applications/Sublime Text.app/Contents/MacOS/sublime_text': '/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl',
+            '/Applications/Sublime Text 2.app/Contents/MacOS/Sublime Text 2': '/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl',
+            '/Applications/Sublime Text Dev.app/Contents/MacOS/Sublime Text': '/Applications/Sublime Text Dev.app/Contents/SharedSupport/bin/subl',
+            '/Applications/Visual Studio Code.app/Contents/MacOS/Electron': 'code',
+            '/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Code - Insiders': 'code-insiders',
+            '/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron': 'code-insiders',
+            '/Applications/VSCodium.app/Contents/MacOS/Electron': 'codium',
+            '/Applications/Cursor.app/Contents/MacOS/Cursor': 'cursor',
+            '/Applications/Trae.app/Contents/MacOS/Electron': 'trae',
+            '/Applications/Antigravity.app/Contents/MacOS/Electron': 'antigravity',
+            '/Applications/AppCode.app/Contents/MacOS/appcode': '/Applications/AppCode.app/Contents/MacOS/appcode',
+            '/Applications/CLion.app/Contents/MacOS/clion': '/Applications/CLion.app/Contents/MacOS/clion',
+            '/Applications/IntelliJ IDEA.app/Contents/MacOS/idea': '/Applications/IntelliJ IDEA.app/Contents/MacOS/idea',
+            '/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea': '/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea',
+            '/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea': '/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea',
+            '/Applications/PhpStorm.app/Contents/MacOS/phpstorm': '/Applications/PhpStorm.app/Contents/MacOS/phpstorm',
+            '/Applications/PyCharm.app/Contents/MacOS/pycharm': '/Applications/PyCharm.app/Contents/MacOS/pycharm',
+            '/Applications/PyCharm CE.app/Contents/MacOS/pycharm': '/Applications/PyCharm CE.app/Contents/MacOS/pycharm',
+            '/Applications/RubyMine.app/Contents/MacOS/rubymine': '/Applications/RubyMine.app/Contents/MacOS/rubymine',
+            '/Applications/WebStorm.app/Contents/MacOS/webstorm': '/Applications/WebStorm.app/Contents/MacOS/webstorm',
+            '/Applications/MacVim.app/Contents/MacOS/MacVim': 'mvim',
+            '/Applications/GoLand.app/Contents/MacOS/goland': '/Applications/GoLand.app/Contents/MacOS/goland',
+            '/Applications/Rider.app/Contents/MacOS/rider': '/Applications/Rider.app/Contents/MacOS/rider',
+            '/Applications/Zed.app/Contents/MacOS/zed': 'zed'
+        };
+    },
+    "../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/editor-info/windows.js" (module) {
+        module.exports = [
+            'Brackets.exe',
+            'Code.exe',
+            'Code - Insiders.exe',
+            'VSCodium.exe',
+            'Cursor.exe',
+            'atom.exe',
+            'sublime_text.exe',
+            'notepad++.exe',
+            'clion.exe',
+            'clion64.exe',
+            'idea.exe',
+            'idea64.exe',
+            'phpstorm.exe',
+            'phpstorm64.exe',
+            'pycharm.exe',
+            'pycharm64.exe',
+            'rubymine.exe',
+            'rubymine64.exe',
+            'webstorm.exe',
+            'webstorm64.exe',
+            'goland.exe',
+            'goland64.exe',
+            'rider.exe',
+            'rider64.exe',
+            'trae.exe',
+            'zed.exe',
+            'Antigravity.exe'
+        ];
+    },
+    "../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/get-args.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let path = __webpack_require__("path");
+        module.exports = function(editor, fileName, lineNumber, columnNumber = 1) {
+            switch(path.basename(editor).replace(/\.(exe|cmd|bat)$/i, '')){
+                case 'atom':
+                case 'Atom':
+                case 'Atom Beta':
+                case 'subl':
+                case 'sublime':
+                case 'sublime_text':
+                case 'wstorm':
+                case 'charm':
+                case 'zed':
+                    return [
+                        `${fileName}:${lineNumber}:${columnNumber}`
+                    ];
+                case 'notepad++':
+                    return [
+                        '-n' + lineNumber,
+                        '-c' + columnNumber,
+                        fileName
+                    ];
+                case 'vim':
+                case 'mvim':
+                    return [
+                        `+call cursor(${lineNumber}, ${columnNumber})`,
+                        fileName
+                    ];
+                case 'joe':
+                case 'gvim':
+                    return [
+                        `+${lineNumber}`,
+                        fileName
+                    ];
+                case 'emacs':
+                case 'emacsclient':
+                    return [
+                        `+${lineNumber}:${columnNumber}`,
+                        fileName
+                    ];
+                case 'rmate':
+                case 'mate':
+                case 'mine':
+                    return [
+                        '--line',
+                        lineNumber,
+                        fileName
+                    ];
+                case 'code':
+                case 'Code':
+                case 'code-insiders':
+                case 'Code - Insiders':
+                case 'codium':
+                case 'trae':
+                case 'antigravity':
+                case 'cursor':
+                case 'vscodium':
+                case 'VSCodium':
+                    return [
+                        '-r',
+                        '-g',
+                        `${fileName}:${lineNumber}:${columnNumber}`
+                    ];
+                case 'appcode':
+                case 'clion':
+                case 'clion64':
+                case 'idea':
+                case 'idea64':
+                case 'phpstorm':
+                case 'phpstorm64':
+                case 'pycharm':
+                case 'pycharm64':
+                case 'rubymine':
+                case 'rubymine64':
+                case 'webstorm':
+                case 'webstorm64':
+                case 'goland':
+                case 'goland64':
+                case 'rider':
+                case 'rider64':
+                    return [
+                        '--line',
+                        lineNumber,
+                        '--column',
+                        columnNumber,
+                        fileName
+                    ];
+            }
+            return process.env.LAUNCH_EDITOR ? [
+                fileName,
+                lineNumber,
+                columnNumber
+            ] : [
+                fileName
+            ];
+        };
+    },
+    "../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/guess.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let path = __webpack_require__("path"), shellQuote = __webpack_require__("../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/index.js"), childProcess = __webpack_require__("child_process"), COMMON_EDITORS_MACOS = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/editor-info/macos.js"), COMMON_EDITORS_LINUX = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/editor-info/linux.js"), COMMON_EDITORS_WIN = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/editor-info/windows.js");
+        module.exports = function(specifiedEditor) {
+            if (specifiedEditor) return shellQuote.parse(specifiedEditor);
+            if (process.env.LAUNCH_EDITOR) return [
+                process.env.LAUNCH_EDITOR
+            ];
+            if (process.versions.webcontainer) return [
+                process.env.EDITOR || 'code'
+            ];
+            try {
+                if ('darwin' === process.platform) {
+                    let output = childProcess.execSync('ps x -o comm=', {
+                        stdio: [
+                            'pipe',
+                            'pipe',
+                            'ignore'
+                        ]
+                    }).toString(), processNames = Object.keys(COMMON_EDITORS_MACOS), processList = output.split('\n');
+                    for(let i = 0; i < processNames.length; i++){
+                        let processName = processNames[i];
+                        if (processList.includes(processName)) return [
+                            COMMON_EDITORS_MACOS[processName]
+                        ];
+                        let processNameWithoutApplications = processName.replace('/Applications', '');
+                        if (-1 !== output.indexOf(processNameWithoutApplications)) {
+                            if (processName !== COMMON_EDITORS_MACOS[processName]) return [
+                                COMMON_EDITORS_MACOS[processName]
+                            ];
+                            let runningProcess = processList.find((procName)=>procName.endsWith(processNameWithoutApplications));
+                            if (void 0 !== runningProcess) return [
+                                runningProcess
+                            ];
+                        }
+                    }
+                } else if ('win32' === process.platform) {
+                    let runningProcesses = childProcess.execSync('powershell -NoProfile -Command "[Console]::OutputEncoding=[Text.Encoding]::UTF8;Get-CimInstance -Query \\"select executablepath from win32_process where executablepath is not null\\" | % { $_.ExecutablePath }"', {
+                        stdio: [
+                            'pipe',
+                            'pipe',
+                            'ignore'
+                        ]
+                    }).toString().split('\r\n');
+                    for(let i = 0; i < runningProcesses.length; i++){
+                        let fullProcessPath = runningProcesses[i].trim(), shortProcessName = path.basename(fullProcessPath);
+                        if (-1 !== COMMON_EDITORS_WIN.indexOf(shortProcessName)) return [
+                            fullProcessPath
+                        ];
+                    }
+                } else if ('linux' === process.platform) {
+                    let output = childProcess.execSync('ps x --no-heading -o comm --sort=comm', {
+                        stdio: [
+                            'pipe',
+                            'pipe',
+                            'ignore'
+                        ]
+                    }).toString(), processNames = Object.keys(COMMON_EDITORS_LINUX);
+                    for(let i = 0; i < processNames.length; i++){
+                        let processName = processNames[i];
+                        if (-1 !== output.indexOf(processName)) return [
+                            COMMON_EDITORS_LINUX[processName]
+                        ];
+                    }
+                }
+            } catch (ignoreError) {}
+            return process.env.VISUAL ? [
+                process.env.VISUAL
+            ] : process.env.EDITOR ? [
+                process.env.EDITOR
+            ] : [
+                null
+            ];
+        };
+    },
+    "../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let fs = __webpack_require__("fs"), os = __webpack_require__("os"), path = __webpack_require__("path"), colors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"), childProcess = __webpack_require__("child_process"), guessEditor = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/guess.js"), getArgumentsForPosition = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/get-args.js"), positionRE = /:(\d+)(:(\d+))?$/, _childProcess = null;
+        module.exports = function(file, specifiedEditor, onErrorCallback) {
+            var file1, cb;
+            let fileName, match, parsed = ((file1 = file).startsWith('file://') && (file1 = __webpack_require__("url").fileURLToPath(file1)), fileName = file1.replace(positionRE, ''), {
+                fileName,
+                lineNumber: (match = file1.match(positionRE)) && match[1],
+                columnNumber: match && match[3]
+            }), { fileName: fileName1 } = parsed, { lineNumber, columnNumber } = parsed;
+            if (!fs.existsSync(fileName1)) return;
+            'function' == typeof specifiedEditor && (onErrorCallback = specifiedEditor, specifiedEditor = void 0), cb = onErrorCallback, onErrorCallback = (fileName, errorMessage)=>{
+                console.log(), console.log(colors.red('Could not open ' + path.basename(fileName) + ' in the editor.')), errorMessage && ('.' !== errorMessage[errorMessage.length - 1] && (errorMessage += '.'), console.log(colors.red('The editor process exited with an error: ' + errorMessage))), console.log(), cb && cb(fileName, errorMessage);
+            };
+            let [editor, ...args] = guessEditor(specifiedEditor);
+            if (!editor) return void onErrorCallback(fileName1, null);
+            if ('linux' === process.platform && fileName1.startsWith('/mnt/') && /Microsoft/i.test(os.release()) && (fileName1 = path.relative('', fileName1)), lineNumber) {
+                let extraArgs = getArgumentsForPosition(editor, fileName1, lineNumber, columnNumber);
+                args.push.apply(args, extraArgs);
+            } else args.push(fileName1);
+            if (_childProcess && function(editor) {
+                switch(editor){
+                    case 'vim':
+                    case 'emacs':
+                    case 'nano':
+                        return !0;
+                }
+                return !1;
+            }(editor) && _childProcess.kill('SIGKILL'), 'win32' === process.platform) {
+                let launchCommand = [
+                    editor,
+                    ...args.map(function(cmdArgs) {
+                        return cmdArgs.replace(/([&|<>,;=^])/g, '^$1');
+                    })
+                ].map(function(str) {
+                    return str.includes('^') ? `^"${str}^"` : str.includes(' ') ? `"${str}"` : str;
+                }).join(' ');
+                _childProcess = childProcess.exec(launchCommand, {
+                    stdio: 'inherit',
+                    shell: !0
+                });
+            } else _childProcess = childProcess.spawn(editor, args, {
+                stdio: 'inherit'
+            });
+            _childProcess.on('exit', function(errorCode) {
+                _childProcess = null, errorCode && onErrorCallback(fileName1, '(code ' + errorCode + ')');
+            }), _childProcess.on('error', function(error) {
+                let { code, message } = error;
+                'ENOENT' === code && (message = `${message} ('${editor}' command does not exist in 'PATH')`), onErrorCallback(fileName1, message);
+            });
+        };
+    },
+    "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
+        let p = process || {}, argv = p.argv || [], env = p.env || {}, 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), 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;
+            }, 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);
+        }, createColors = (enabled = isColorSupported)=>{
+            let f = enabled ? formatter : ()=>String;
+            return {
+                isColorSupported: enabled,
+                reset: f("\x1b[0m", "\x1b[0m"),
+                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+                italic: f("\x1b[3m", "\x1b[23m"),
+                underline: f("\x1b[4m", "\x1b[24m"),
+                inverse: f("\x1b[7m", "\x1b[27m"),
+                hidden: f("\x1b[8m", "\x1b[28m"),
+                strikethrough: f("\x1b[9m", "\x1b[29m"),
+                black: f("\x1b[30m", "\x1b[39m"),
+                red: f("\x1b[31m", "\x1b[39m"),
+                green: f("\x1b[32m", "\x1b[39m"),
+                yellow: f("\x1b[33m", "\x1b[39m"),
+                blue: f("\x1b[34m", "\x1b[39m"),
+                magenta: f("\x1b[35m", "\x1b[39m"),
+                cyan: f("\x1b[36m", "\x1b[39m"),
+                white: f("\x1b[37m", "\x1b[39m"),
+                gray: f("\x1b[90m", "\x1b[39m"),
+                bgBlack: f("\x1b[40m", "\x1b[49m"),
+                bgRed: f("\x1b[41m", "\x1b[49m"),
+                bgGreen: f("\x1b[42m", "\x1b[49m"),
+                bgYellow: f("\x1b[43m", "\x1b[49m"),
+                bgBlue: f("\x1b[44m", "\x1b[49m"),
+                bgMagenta: f("\x1b[45m", "\x1b[49m"),
+                bgCyan: f("\x1b[46m", "\x1b[49m"),
+                bgWhite: f("\x1b[47m", "\x1b[49m"),
+                blackBright: f("\x1b[90m", "\x1b[39m"),
+                redBright: f("\x1b[91m", "\x1b[39m"),
+                greenBright: f("\x1b[92m", "\x1b[39m"),
+                yellowBright: f("\x1b[93m", "\x1b[39m"),
+                blueBright: f("\x1b[94m", "\x1b[39m"),
+                magentaBright: f("\x1b[95m", "\x1b[39m"),
+                cyanBright: f("\x1b[96m", "\x1b[39m"),
+                whiteBright: f("\x1b[97m", "\x1b[39m"),
+                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+                bgRedBright: f("\x1b[101m", "\x1b[49m"),
+                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
+            };
+        };
+        module.exports = createColors(), module.exports.createColors = createColors;
+    },
+    "../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let valueOf = Symbol.prototype.valueOf, typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
+        module.exports = function(val, deep) {
+            var val1, val2, val3, val4, val5;
+            switch(typeOf(val)){
+                case 'array':
+                    return val.slice();
+                case 'object':
+                    return Object.assign({}, val);
+                case 'date':
+                    return new val.constructor(Number(val));
+                case 'map':
+                    return new Map(val);
+                case 'set':
+                    return new Set(val);
+                case 'buffer':
+                    let len, buf;
+                    return len = (val1 = val).length, buf = Buffer.allocUnsafe ? Buffer.allocUnsafe(len) : Buffer.from(len), val1.copy(buf), buf;
+                case 'symbol':
+                    return val2 = val, valueOf ? Object(valueOf.call(val2)) : {};
+                case 'arraybuffer':
+                    let res;
+                    return new Uint8Array(res = new (val3 = val).constructor(val3.byteLength)).set(new Uint8Array(val3)), res;
+                case 'float32array':
+                case 'float64array':
+                case 'int16array':
+                case 'int32array':
+                case 'int8array':
+                case 'uint16array':
+                case 'uint32array':
+                case 'uint8clampedarray':
+                case 'uint8array':
+                    return new (val4 = val).constructor(val4.buffer, val4.byteOffset, val4.length);
+                case 'regexp':
+                    let flags, re;
+                    return flags = void 0 !== (val5 = val).flags ? val5.flags : /\w+$/.exec(val5) || void 0, (re = new val5.constructor(val5.source, flags)).lastIndex = val5.lastIndex, re;
+                case 'error':
+                    return Object.create(val);
+                default:
+                    return val;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.quote = __webpack_require__("../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js"), exports.parse = __webpack_require__("../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js");
+    },
+    "../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js" (module) {
+        for(var CONTROL = "(?:\\|\\||\\&\\&|;;|\\|\\&|\\<\\(|\\<\\<\\<|>>|>\\&|<\\&|[&;()|<>])", controlRE = RegExp('^' + CONTROL + '$'), META = '|&;()<> \\t', hash = /^#$/, TOKEN = '', i = 0; i < 4; i++)TOKEN += (0x100000000 * Math.random()).toString(16);
+        var startsWithToken = RegExp('^' + TOKEN);
+        module.exports = function(s, env, opts) {
+            var mapped = function(string, env, opts) {
+                opts || (opts = {});
+                var BS = opts.escape || '\\', matches = function(s, r) {
+                    for(var matchObj, origIndex = r.lastIndex, matches = []; matchObj = r.exec(s);)matches.push(matchObj), r.lastIndex === matchObj.index && (r.lastIndex += 1);
+                    return r.lastIndex = origIndex, matches;
+                }(string, RegExp([
+                    '(' + CONTROL + ')',
+                    '(' + ('(\\' + BS + '[\'"' + META + ']|[^\\s\'"' + META) + "])+|\"((\\\\\"|[^\"])*?)\"|'((\\\\'|[^'])*?)')+"
+                ].join('|'), 'g'));
+                if (0 === matches.length) return [];
+                env || (env = {});
+                var commented = !1;
+                return matches.map(function(match) {
+                    var i, s = match[0];
+                    if (s && !commented) {
+                        if (controlRE.test(s)) return {
+                            op: s
+                        };
+                        var quote = !1, esc = !1, out = '', isGlob = !1;
+                        for(i = 0; i < s.length; i++){
+                            var c = s.charAt(i);
+                            if (isGlob = isGlob || !quote && ('*' === c || '?' === c), esc) out += c, esc = !1;
+                            else if (quote) c === quote ? quote = !1 : "'" == quote ? out += c : c === BS ? (i += 1, '"' === (c = s.charAt(i)) || c === BS || '$' === c ? out += c : out += BS + c) : '$' === c ? out += parseEnvVar() : out += c;
+                            else if ('"' === c || "'" === c) quote = c;
+                            else if (controlRE.test(c)) return {
+                                op: s
+                            };
+                            else if (hash.test(c)) {
+                                commented = !0;
+                                var commentObj = {
+                                    comment: string.slice(match.index + i + 1)
+                                };
+                                if (out.length) return [
+                                    out,
+                                    commentObj
+                                ];
+                                return [
+                                    commentObj
+                                ];
+                            } else c === BS ? esc = !0 : '$' === c ? out += parseEnvVar() : out += c;
+                        }
+                        return isGlob ? {
+                            op: 'glob',
+                            pattern: out
+                        } : out;
+                    }
+                    function parseEnvVar() {
+                        i += 1;
+                        var env1, key, r, varend, varname, char = s.charAt(i);
+                        if ('{' === char) {
+                            if (i += 1, '}' === s.charAt(i)) throw Error('Bad substitution: ' + s.slice(i - 2, i + 1));
+                            if ((varend = s.indexOf('}', i)) < 0) throw Error('Bad substitution: ' + s.slice(i));
+                            varname = s.slice(i, varend), i = varend;
+                        } else if (/[*@#?$!_-]/.test(char)) varname = char, i += 1;
+                        else {
+                            var slicedFromI = s.slice(i);
+                            (varend = slicedFromI.match(/[^\w\d_]/)) ? (varname = slicedFromI.slice(0, varend.index), i += varend.index - 1) : (varname = slicedFromI, i = s.length);
+                        }
+                        return env1 = env, key = varname, (void 0 === (r = 'function' == typeof env1 ? env1(key) : env1[key]) && '' != key ? r = '' : void 0 === r && (r = '$'), 'object' == typeof r) ? '' + TOKEN + JSON.stringify(r) + TOKEN : '' + r;
+                    }
+                }).reduce(function(prev, arg) {
+                    return void 0 === arg ? prev : prev.concat(arg);
+                }, []);
+            }(s, env, opts);
+            return 'function' != typeof env ? mapped : mapped.reduce(function(acc, s) {
+                if ('object' == typeof s) return acc.concat(s);
+                var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
+                return 1 === xs.length ? acc.concat(xs[0]) : acc.concat(xs.filter(Boolean).map(function(x) {
+                    return startsWithToken.test(x) ? JSON.parse(x.split(TOKEN)[1]) : x;
+                }));
+            }, []);
+        };
+    },
+    "../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js" (module) {
+        module.exports = function(xs) {
+            return xs.map(function(s) {
+                return '' === s ? '\'\'' : s && 'object' == typeof s ? s.op.replace(/(.)/g, '\\$1') : /["\s\\]/.test(s) && !/'/.test(s) ? "'" + s.replace(/(['])/g, '\\$1') + "'" : /["'\s]/.test(s) ? '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"' : String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, '$1\\$2');
+            }).join(' ');
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }, __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+            if (pack || 2 == arguments.length) for(var ar, i = 0, l = from.length; i < l; i++)!ar && i in from || (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+            return to.concat(ar || Array.prototype.slice.call(from));
+        }, __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.unique = exports.mergeWithRules = exports.mergeWithCustomize = exports.default = exports.merge = exports.CustomizeRule = exports.customizeObject = exports.customizeArray = void 0;
+        var wildcard_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/wildcard@2.0.1/node_modules/wildcard/index.js")), merge_with_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/merge-with.js")), join_arrays_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/join-arrays.js"));
+        exports.unique = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/unique.js")).default;
+        var types_1 = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/types.js");
+        Object.defineProperty(exports, "CustomizeRule", {
+            enumerable: !0,
+            get: function() {
+                return types_1.CustomizeRule;
+            }
+        });
+        var utils_1 = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/utils.js");
+        function merge(firstConfiguration) {
+            for(var configurations = [], _i = 1; _i < arguments.length; _i++)configurations[_i - 1] = arguments[_i];
+            return mergeWithCustomize({}).apply(void 0, __spreadArray([
+                firstConfiguration
+            ], __read(configurations), !1));
+        }
+        function mergeWithCustomize(options) {
+            return function(firstConfiguration) {
+                for(var configurations = [], _i = 1; _i < arguments.length; _i++)configurations[_i - 1] = arguments[_i];
+                if ((0, utils_1.isUndefined)(firstConfiguration) || configurations.some(utils_1.isUndefined)) throw TypeError("Merging undefined is not supported");
+                if (firstConfiguration.then) throw TypeError("Promises are not supported");
+                if (!firstConfiguration) return {};
+                if (0 === configurations.length) {
+                    if (Array.isArray(firstConfiguration)) {
+                        if (0 === firstConfiguration.length) return {};
+                        if (firstConfiguration.some(utils_1.isUndefined)) throw TypeError("Merging undefined is not supported");
+                        if (firstConfiguration[0].then) throw TypeError("Promises are not supported");
+                        return (0, merge_with_1.default)(firstConfiguration, (0, join_arrays_1.default)(options));
+                    }
+                    return firstConfiguration;
+                }
+                return (0, merge_with_1.default)([
+                    firstConfiguration
+                ].concat(configurations), (0, join_arrays_1.default)(options));
+            };
+        }
+        exports.merge = merge, exports.default = merge, exports.mergeWithCustomize = mergeWithCustomize, exports.customizeArray = function(rules) {
+            return function(a, b, key) {
+                var matchedRule = Object.keys(rules).find(function(rule) {
+                    return (0, wildcard_1.default)(rule, key);
+                }) || "";
+                if (matchedRule) switch(rules[matchedRule]){
+                    case types_1.CustomizeRule.Prepend:
+                        return __spreadArray(__spreadArray([], __read(b), !1), __read(a), !1);
+                    case types_1.CustomizeRule.Replace:
+                        return b;
+                    case types_1.CustomizeRule.Append:
+                    default:
+                        return __spreadArray(__spreadArray([], __read(a), !1), __read(b), !1);
+                }
+            };
+        }, exports.mergeWithRules = function(rules) {
+            return mergeWithCustomize({
+                customizeArray: function(a, b, key) {
+                    var currentRule = rules;
+                    return (key.split(".").forEach(function(k) {
+                        currentRule && (currentRule = currentRule[k]);
+                    }), (0, utils_1.isPlainObject)(currentRule)) ? function mergeWithRule(_a) {
+                        var currentRule = _a.currentRule, a = _a.a, b = _a.b;
+                        if (!isArray(a)) return a;
+                        var bAllMatches = [];
+                        return a.map(function(ao) {
+                            if (!(0, utils_1.isPlainObject)(currentRule)) return ao;
+                            var ret = {}, rulesToMatch = [], operations = {};
+                            Object.entries(currentRule).forEach(function(_a) {
+                                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                                v === types_1.CustomizeRule.Match ? rulesToMatch.push(k) : operations[k] = v;
+                            });
+                            var bMatches = b.filter(function(o) {
+                                var matches = rulesToMatch.every(function(rule) {
+                                    return (0, utils_1.isSameCondition)(ao[rule], o[rule]);
+                                });
+                                return matches && bAllMatches.push(o), matches;
+                            });
+                            return (0, utils_1.isPlainObject)(ao) ? (Object.entries(ao).forEach(function(_a) {
+                                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                                switch(currentRule[k]){
+                                    case types_1.CustomizeRule.Match:
+                                        ret[k] = v, Object.entries(currentRule).forEach(function(_a) {
+                                            var _b = __read(_a, 2), k = _b[0];
+                                            if (_b[1] === types_1.CustomizeRule.Replace && bMatches.length > 0) {
+                                                var val = last(bMatches)[k];
+                                                void 0 !== val && (ret[k] = val);
+                                            }
+                                        });
+                                        break;
+                                    case types_1.CustomizeRule.Append:
+                                        if (!bMatches.length) {
+                                            ret[k] = v;
+                                            break;
+                                        }
+                                        var appendValue = last(bMatches)[k];
+                                        if (!isArray(v) || !isArray(appendValue)) throw TypeError("Trying to append non-arrays");
+                                        ret[k] = v.concat(appendValue);
+                                        break;
+                                    case types_1.CustomizeRule.Merge:
+                                        if (!bMatches.length) {
+                                            ret[k] = v;
+                                            break;
+                                        }
+                                        var lastValue = last(bMatches)[k];
+                                        if (!(0, utils_1.isPlainObject)(v) || !(0, utils_1.isPlainObject)(lastValue)) throw TypeError("Trying to merge non-objects");
+                                        ret[k] = merge(v, lastValue);
+                                        break;
+                                    case types_1.CustomizeRule.Prepend:
+                                        if (!bMatches.length) {
+                                            ret[k] = v;
+                                            break;
+                                        }
+                                        var prependValue = last(bMatches)[k];
+                                        if (!isArray(v) || !isArray(prependValue)) throw TypeError("Trying to prepend non-arrays");
+                                        ret[k] = prependValue.concat(v);
+                                        break;
+                                    case types_1.CustomizeRule.Replace:
+                                        ret[k] = bMatches.length > 0 ? last(bMatches)[k] : v;
+                                        break;
+                                    default:
+                                        var currentRule_1 = operations[k], b_1 = bMatches.map(function(o) {
+                                            return o[k];
+                                        }).reduce(function(acc, val) {
+                                            return isArray(acc) && isArray(val) ? __spreadArray(__spreadArray([], __read(acc), !1), __read(val), !1) : acc;
+                                        }, []);
+                                        ret[k] = mergeWithRule({
+                                            currentRule: currentRule_1,
+                                            a: v,
+                                            b: b_1
+                                        });
+                                }
+                            }), ret) : ao;
+                        }).concat(b.filter(function(o) {
+                            return !bAllMatches.includes(o);
+                        }));
+                    }({
+                        currentRule: currentRule,
+                        a: a,
+                        b: b
+                    }) : "string" == typeof currentRule ? function(_a) {
+                        var currentRule = _a.currentRule, a = _a.a, b = _a.b;
+                        switch(currentRule){
+                            case types_1.CustomizeRule.Append:
+                                return a.concat(b);
+                            case types_1.CustomizeRule.Prepend:
+                                return b.concat(a);
+                            case types_1.CustomizeRule.Replace:
+                                return b;
+                        }
+                        return a;
+                    }({
+                        currentRule: currentRule,
+                        a: a,
+                        b: b
+                    }) : void 0;
+                }
+            });
+        };
+        var isArray = Array.isArray;
+        function last(arr) {
+            return arr[arr.length - 1];
+        }
+        exports.customizeObject = function(rules) {
+            return function(a, b, key) {
+                switch(rules[key]){
+                    case types_1.CustomizeRule.Prepend:
+                        return (0, merge_with_1.default)([
+                            b,
+                            a
+                        ], (0, join_arrays_1.default)());
+                    case types_1.CustomizeRule.Replace:
+                        return b;
+                    case types_1.CustomizeRule.Append:
+                        return (0, merge_with_1.default)([
+                            a,
+                            b
+                        ], (0, join_arrays_1.default)());
+                }
+            };
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/join-arrays.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }, __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+            if (pack || 2 == arguments.length) for(var ar, i = 0, l = from.length; i < l; i++)!ar && i in from || (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+            return to.concat(ar || Array.prototype.slice.call(from));
+        }, __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        });
+        var clone_deep_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js")), merge_with_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/merge-with.js")), utils_1 = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/utils.js"), isArray = Array.isArray;
+        exports.default = function joinArrays(_a) {
+            var _b = void 0 === _a ? {} : _a, customizeArray = _b.customizeArray, customizeObject = _b.customizeObject, key = _b.key;
+            return function _joinArrays(a, b, k) {
+                var newKey = key ? "".concat(key, ".").concat(k) : k;
+                if ((0, utils_1.isFunction)(a) && (0, utils_1.isFunction)(b)) return function() {
+                    for(var args = [], _i = 0; _i < arguments.length; _i++)args[_i] = arguments[_i];
+                    return _joinArrays(a.apply(void 0, __spreadArray([], __read(args), !1)), b.apply(void 0, __spreadArray([], __read(args), !1)), k);
+                };
+                if (isArray(a) && isArray(b)) {
+                    var customResult = customizeArray && customizeArray(a, b, newKey);
+                    return customResult || __spreadArray(__spreadArray([], __read(a), !1), __read(b), !1);
+                }
+                if ((0, utils_1.isRegex)(b)) return b;
+                if ((0, utils_1.isPlainObject)(a) && (0, utils_1.isPlainObject)(b)) {
+                    var customResult = customizeObject && customizeObject(a, b, newKey);
+                    return customResult || (0, merge_with_1.default)([
+                        a,
+                        b
+                    ], joinArrays({
+                        customizeArray: customizeArray,
+                        customizeObject: customizeObject,
+                        key: newKey
+                    }));
+                }
+                return (0, utils_1.isPlainObject)(b) ? (0, clone_deep_1.default)(b) : isArray(b) ? __spreadArray([], __read(b), !1) : b;
+            };
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/merge-with.js" (__unused_rspack_module, exports) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.default = function(objects, customizer) {
+            var _a = __read(objects), first = _a[0], rest = _a.slice(1), ret = first;
+            return rest.forEach(function(a) {
+                var a1, b, customizer1, ret1;
+                a1 = ret, b = a, customizer1 = customizer, ret1 = {}, Object.keys(a1).concat(Object.keys(b)).forEach(function(k) {
+                    var v = customizer1(a1[k], b[k], k);
+                    ret1[k] = void 0 === v ? a1[k] : v;
+                }), ret = ret1;
+            }), ret;
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/types.js" (__unused_rspack_module, exports) {
+        var CustomizeRule, CustomizeRule1;
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.CustomizeRule = void 0, (CustomizeRule1 = CustomizeRule || (exports.CustomizeRule = CustomizeRule = {})).Match = "match", CustomizeRule1.Merge = "merge", CustomizeRule1.Append = "append", CustomizeRule1.Prepend = "prepend", CustomizeRule1.Replace = "replace";
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/unique.js" (__unused_rspack_module, exports) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }, __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+            if (pack || 2 == arguments.length) for(var ar, i = 0, l = from.length; i < l; i++)!ar && i in from || (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+            return to.concat(ar || Array.prototype.slice.call(from));
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.default = function(key, uniques, getter) {
+            var uniquesSet = new Set(uniques);
+            return function(a, b, k) {
+                return k === key && Array.from(__spreadArray(__spreadArray([], __read(a), !1), __read(b), !1).map(function(it) {
+                    return {
+                        key: getter(it),
+                        value: it
+                    };
+                }).map(function(_a) {
+                    var key = _a.key, value = _a.value;
+                    return {
+                        key: uniquesSet.has(key) ? key : value,
+                        value: value
+                    };
+                }).reduce(function(m, _a) {
+                    var key = _a.key, value = _a.value;
+                    return m.delete(key), m.set(key, value);
+                }, new Map()).values());
+            };
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.isSameCondition = exports.isUndefined = exports.isPlainObject = exports.isFunction = exports.isRegex = void 0;
+        var flat_1 = __webpack_require__("../../node_modules/.pnpm/flat@5.0.2/node_modules/flat/index.js");
+        function isRegex(o) {
+            return o instanceof RegExp;
+        }
+        function isFunction(functionToCheck) {
+            return functionToCheck && "[object Function]" === ({}).toString.call(functionToCheck);
+        }
+        exports.isRegex = isRegex, exports.isFunction = isFunction, exports.isPlainObject = function(a) {
+            return !(null === a || Array.isArray(a)) && "object" == typeof a;
+        }, exports.isUndefined = function(a) {
+            return void 0 === a;
+        }, exports.isSameCondition = function(a, b) {
+            if (!a || !b) return a === b;
+            if ("string" == typeof a || "string" == typeof b || isRegex(a) || isRegex(b) || isFunction(a) || isFunction(b)) return a.toString() === b.toString();
+            var _a, _b, entriesA = Object.entries((0, flat_1.flatten)(a)), entriesB = Object.entries((0, flat_1.flatten)(b));
+            if (entriesA.length !== entriesB.length) return !1;
+            for(var i = 0; i < entriesA.length; i++)entriesA[i][0] = entriesA[i][0].replace(/\b\d+\b/g, "[]"), entriesB[i][0] = entriesB[i][0].replace(/\b\d+\b/g, "[]");
+            function cmp(_a, _b) {
+                var _c = __read(_a, 2), k1 = _c[0], v1 = _c[1], _d = __read(_b, 2), k2 = _d[0], v2 = _d[1];
+                return k1 < k2 ? -1 : k1 > k2 ? 1 : v1 < v2 ? -1 : +(v1 > v2);
+            }
+            if (entriesA.sort(cmp), entriesB.sort(cmp), entriesA.length !== entriesB.length) return !1;
+            for(var i = 0; i < entriesA.length; i++)if (entriesA[i][0] !== entriesB[i][0] || (null == (_a = entriesA[i][1]) ? void 0 : _a.toString()) !== (null == (_b = entriesB[i][1]) ? void 0 : _b.toString())) return !1;
+            return !0;
+        };
     },
-    "compiled/webpack-merge" (module) {
-        module.exports = __rspack_external__compiled_webpack_merge_index_js_efd91626;
+    "../../node_modules/.pnpm/wildcard@2.0.1/node_modules/wildcard/index.js" (module) {
+        var REGEXP_PARTS = /(\*|\?)/g;
+        function WildcardMatcher(text, separator) {
+            this.text = text = text || '', this.hasWild = text.indexOf('*') >= 0, this.separator = separator, this.parts = text.split(separator).map(this.classifyPart.bind(this));
+        }
+        WildcardMatcher.prototype.match = function(input) {
+            var ii, testParts, matches = !0, parts = this.parts, partsCount = parts.length;
+            if ('string' == typeof input || input instanceof String) if (this.hasWild || this.text == input) {
+                for(ii = 0, testParts = (input || '').split(this.separator); matches && ii < partsCount; ii++)if ('*' === parts[ii]) continue;
+                else matches = ii < testParts.length && (parts[ii] instanceof RegExp ? parts[ii].test(testParts[ii]) : parts[ii] === testParts[ii]);
+                matches = matches && testParts;
+            } else matches = !1;
+            else if ('function' == typeof input.splice) for(matches = [], ii = input.length; ii--;)this.match(input[ii]) && (matches[matches.length] = input[ii]);
+            else if ('object' == typeof input) for(var key in matches = {}, input)this.match(key) && (matches[key] = input[key]);
+            return matches;
+        }, WildcardMatcher.prototype.classifyPart = function(part) {
+            if ('*' === part) ;
+            else if (part.indexOf('*') >= 0 || part.indexOf('?') >= 0) return new RegExp(part.replace(REGEXP_PARTS, '\.$1'));
+            return part;
+        }, module.exports = function(text, test, separator) {
+            var matcher = new WildcardMatcher(text, separator || /[\/\.]/);
+            return void 0 !== test ? matcher.match(test) : matcher;
+        };
+    },
+    child_process (module) {
+        module.exports = __rspack_external_child_process;
+    },
+    fs (module) {
+        module.exports = __rspack_external_fs;
+    },
+    os (module) {
+        module.exports = __rspack_external_os;
+    },
+    path (module) {
+        module.exports = __rspack_external_path;
+    },
+    url (module) {
+        module.exports = __rspack_external_url;
     }
 });
 let isCI = !!process.env.CI, isTTY = !!process.stdout?.isTTY, noColor = !!process.env.NO_COLOR, forceColor = !!process.env.FORCE_COLOR, disableColor = !1;
@@ -119,9 +1217,9 @@ let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULE
   <body>
     <div id="${mountId}"></div>
   </body>
-</html>`, JS_REGEX = /\.[jt]s$/, JSX_REGEX = /\.[jt]sx$/, SCRIPT_REGEX = /\.[jt]sx?$/;
+</html>`, JS_REGEX = /\.[jt]s$/, JSX_REGEX = /\.[jt]sx$/, SCRIPT_REGEX = /\.[jt]sx?$/, CSS_REGEX = /\.css$/i, LESS_REGEX = /\.less$/i, SASS_REGEX = /\.s[ac]ss$/i;
 var utils_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-let { merge: utils_mergeConfig } = __webpack_require__("compiled/webpack-merge"), { default: launchEditor } = __webpack_require__("compiled/launch-editor"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
+let getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
     process.env.NODE_ENV = env;
 }, setDevServer = (isDevServer)=>{
     process.env.DEV_SERVER = isDevServer ? 'true' : 'false';
@@ -540,6 +1638,8 @@ let removeDir = (dir)=>{
     currentUnpackConfig = config;
 }, unpackStartTime = 0, getUnpackStartTime = ()=>unpackStartTime, setUnpackStartTime = (time)=>{
     unpackStartTime = time;
+}, getDevServerPort = ()=>devServerPort, setDevServerPort = (port)=>{
+    devServerPort = port;
 }, STYLE_IMPORT_RE = /import\s+((?:(?!\nimport\s)[\s\S])*?)\s+from\s+(['"])([^'"]+?\.(?:css|less|scss|sass)(?:\?[^'"]+)?(?:#[^'"]+)?)\2/g, TYPE_IMPORT_CLAUSE_RE = /^\s*type\b/, STYLE_EXT_HINTS = [
     '.css',
     '.less',
@@ -657,7 +1757,18 @@ let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|
     if ('function' == typeof symbolId) return symbolId(name, filePath);
     let id = (symbolId || 'icon-[dir]-[name]').replace(/\[name\]/g, name).replace(/\[dir\]/g, dir);
     return id.replace(/--+/g, '-').replace(/^-+|-+$/g, '');
-}, UNOCSS_CONFIG_FILES = [
+}, BROWSERSLIST_CONFIG_FILES = [
+    '.browserslistrc',
+    '.browserslistrc.json',
+    '.browserslistrc.yaml',
+    '.browserslistrc.yml',
+    'browserslist',
+    'browserslist.config.js',
+    'browserslist.config.cjs',
+    'browserslist.config.mjs'
+], dist = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js");
+var dist_default = __webpack_require__.n(dist), dist_default_0 = dist_default();
+let UNOCSS_CONFIG_FILES = [
     'unocss.config.mjs',
     'unocss.config.ts',
     'unocss.config.js',
@@ -670,10 +1781,12 @@ let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|
     if (!view) return (css)=>css;
     let prefix = {};
     return view.trim().replace(/(\\*)\\(["'`\\])/g, (_, bs, char)=>(prefix[char] = bs.replace(/\\\\/g, '\\'), '')), (css)=>css.replace(/["'`\\]/g, (v)=>(prefix[v] || '') + v);
-}, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+}, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm, TRANSFORM_TIMING_STORE = Symbol.for('unpack:transformTimingMap'), PLUGIN_CONTEXT_STORE = Symbol.for('unpack:pluginContextStore'), globalScope = globalThis;
+globalScope[TRANSFORM_TIMING_STORE] ??= new WeakMap(), globalScope[PLUGIN_CONTEXT_STORE] ??= new WeakMap();
+let flattenUnpackPlugins = ()=>getCurrentUnpackConfig().plugins?.flat(1 / 0) || [];
 function getNormalizedPluginsByHook(hook) {
     let pluginMap = new Map();
-    (getCurrentUnpackConfig().plugins?.flat(1 / 0) || []).forEach((plugin)=>{
+    flattenUnpackPlugins().forEach((plugin)=>{
         plugin && ((plugin, hook)=>{
             if (!plugin[hook]) return !1;
             let apply = plugin.apply;
@@ -682,7 +1795,9 @@ function getNormalizedPluginsByHook(hook) {
                 mode: getNodeEnv(),
                 command: utils_isDevServer() ? 'dev' : 'build'
             };
-            return 'string' == typeof apply ? apply === env.command : !!apply(getCurrentUnpackConfig(), env);
+            if ('string' == typeof apply) return apply === env.command;
+            let config = getCurrentUnpackConfig(), context = createPluginContext(plugin);
+            return !!apply.call(context, config, env);
         })(plugin, hook) && pluginMap.set(plugin.name, plugin);
     });
     let normalizedPlugins = Array.from(pluginMap.values()), enforceOrder = (plugin)=>'pre' === plugin.enforce ? 0 : 'post' === plugin.enforce ? 2 : 1;
@@ -694,7 +1809,7 @@ function getNormalizedPluginsByHook(hook) {
         return 0 !== diff ? diff : a.index - b.index;
     }).map((item)=>item.plugin);
 }
-let createPluginHookTimer = (plugin, hook)=>{
+let createPluginHookTimer = (pluginName, hook)=>{
     let startTime = 0;
     return {
         start: ()=>{
@@ -702,22 +1817,40 @@ let createPluginHookTimer = (plugin, hook)=>{
         },
         end: ()=>{
             let duration = performance.now() - startTime;
-            logger_logger.debug(`${colors.magenta('[plugin]')} ${colors.cyan(plugin.name)} ${colors.blue(hook)} ${colors.dim('in')} ${colors.yellow(`${duration.toFixed(2)}ms`)}`);
+            logger_logger.debug(`${colors.magenta('[plugin]')} ${colors.cyan(pluginName)} ${colors.blue(hook)} ${colors.dim('in')} ${colors.yellow(`${duration.toFixed(2)}ms`)}`);
         }
     };
-}, TRANSFORM_TIMING_STORE = Symbol.for('unpack:transformTimingMap'), globalScope = globalThis, transformTimingMap = globalScope[TRANSFORM_TIMING_STORE] ?? new WeakMap();
+}, transformTimingMap = globalScope[TRANSFORM_TIMING_STORE], pluginContextStore = globalScope[PLUGIN_CONTEXT_STORE], createPluginContext = (plugin)=>{
+    let cached = pluginContextStore.get(plugin);
+    if (cached) return cached;
+    let context = {
+        name: plugin.name,
+        get port () {
+            return getDevServerPort();
+        },
+        get cachePath () {
+            return getCurrentUnpackConfig()._context.cachePath;
+        },
+        info: (msg)=>logger_logger.info(msg),
+        warn: (msg)=>logger_logger.warn(msg),
+        error: (msg)=>logger_logger.error(msg),
+        debug: (msg)=>logger_logger.debug(msg),
+        isPluginExists: (name)=>flattenUnpackPlugins().some((item)=>item && item.name === name)
+    };
+    return pluginContextStore.set(plugin, context), context;
+};
 async function applyPluginsByHook(hook, runner) {
     let shouldMeasure = 'processAssets' !== hook && 'transform' !== hook;
     for (let plugin of getNormalizedPluginsByHook(hook)){
-        let impl = plugin[hook];
+        let impl = plugin[hook], context = createPluginContext(plugin);
         if (!shouldMeasure) {
-            await runner(impl, plugin);
+            await runner(impl, context);
             continue;
         }
-        let timer = createPluginHookTimer(plugin, hook);
+        let timer = createPluginHookTimer(plugin.name, hook);
         timer.start();
         try {
-            await runner(impl, plugin);
+            await runner(impl, context);
         } finally{
             timer.end();
         }
@@ -726,35 +1859,20 @@ async function applyPluginsByHook(hook, runner) {
 function applyPluginsByHookSync(hook, runner) {
     let shouldMeasure = 'processAssets' !== hook && 'transform' !== hook;
     for (let plugin of getNormalizedPluginsByHook(hook)){
-        let impl = plugin[hook];
+        let impl = plugin[hook], context = createPluginContext(plugin);
         if (!shouldMeasure) {
-            runner(impl, plugin);
+            runner(impl, context);
             continue;
         }
-        let timer = createPluginHookTimer(plugin, hook);
+        let timer = createPluginHookTimer(plugin.name, hook);
         timer.start();
         try {
-            runner(impl, plugin);
+            runner(impl, context);
         } finally{
             timer.end();
         }
     }
 }
-async function applyBuildAnalyzeConfig({ config, unpackConfig }) {
-    let { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
-    return config.plugins?.push(new RsdoctorRspackPlugin({
-        linter: {
-            rules: {
-                'ecma-version-check': [
-                    'Warn',
-                    {
-                        targets: esVersionToBrowserslist(unpackConfig.build.target)
-                    }
-                ]
-            }
-        }
-    })), config.devtool = 'source-map', config;
-}
 async function getBuildDependencies(root) {
     let rootPackageJson = node_path.join(root, 'package.json'), browserslistConfig = node_path.join(root, '.browserslistrc'), tsconfigPath = node_path.join(root, 'tsconfig.json'), buildDependencies = {};
     await isFileExists(rootPackageJson) && (buildDependencies.packageJson = [
@@ -782,7 +1900,7 @@ async function applyCacheConfig({ config, unpackConfig, envFilePaths }) {
     let cacheConfig = isPlainObject(unpackConfig.performance.cache) ? unpackConfig.performance.cache : {}, buildDependencies = await getBuildDependencies(unpackConfig.root);
     buildDependencies.userBuildDependencies = cacheConfig.buildDependencies || [], buildDependencies.envFilePaths = envFilePaths;
     let cacheDirectory = node_path.resolve(unpackConfig.root, cacheConfig.cacheDirectory || `${unpackConfig._context.cachePath}/cache`, utils_isDevServer() ? 'dev' : 'build');
-    return utils_mergeConfig(config, {
+    return dist_default()(config, {
         cache: {
             type: 'persistent',
             buildDependencies: Object.values(buildDependencies).flat(),
@@ -801,16 +1919,12 @@ async function getEntry(root, customEntry) {
     }))[0], !node_fs.existsSync(entry)) throw Error('could not find entry file');
     return entry;
 }
-globalScope[TRANSFORM_TIMING_STORE] = transformTimingMap;
 let getOutputFilename = ({ type, hash, async })=>{
     let FILENAME = utils_isProd() && !1 !== hash ? PROD_DEFAULT_FILENAME : DEV_DEFAULT_FILENAME;
     return async ? 'js' === type ? FILENAME.jsAsync : FILENAME.cssAsync : FILENAME[type];
 }, getCssLoader = (unpackConfig)=>unpackConfig.css?.transformer === 'lightningcss' ? {
         loader: 'builtin:lightningcss-loader',
-        options: {
-            targets: esVersionToBrowserslist(unpackConfig.build.target),
-            ...unpackConfig.css?.lightningcssLoader
-        }
+        options: unpackConfig.css?.lightningcssLoader
     } : {
         loader: getCompiledPkgPath('postcss-loader'),
         options: {
@@ -830,7 +1944,7 @@ let getOutputFilename = ({ type, hash, async })=>{
         }
     }), getLessLoader = (unpackConfig)=>({
         loader: getCompiledPkgPath('less-loader'),
-        options: utils_mergeConfig({
+        options: dist_default()({
             lessOptions: {
                 javascriptEnabled: !0
             },
@@ -870,7 +1984,7 @@ class JsMinifyPlugin {
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "4.6.1",
+            version: "4.7.1",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -997,13 +2111,13 @@ class RegisterHooksPlugin {
         virtualModulesPlugin.apply(compiler);
         let resolveIdPlugins = getNormalizedPluginsByHook('resolveId'), loadPlugins = getNormalizedPluginsByHook('load'), resolveId = async (id, importer)=>{
             for (let plugin of resolveIdPlugins){
-                let start = performance.now(), result = await plugin.resolveId(id, importer), duration = performance.now() - start;
+                let context = createPluginContext(plugin), start = performance.now(), result = await plugin.resolveId.call(context, id, importer), duration = performance.now() - start;
                 if (this.resolveIdTimings.set(plugin.name, (this.resolveIdTimings.get(plugin.name) || 0) + duration), 'string' == typeof result && result) return result;
             }
             return null;
         }, load = async (id)=>{
             for (let plugin of loadPlugins){
-                let start = performance.now(), result = await plugin.load(id), duration = performance.now() - start;
+                let context = createPluginContext(plugin), start = performance.now(), result = await plugin.load.call(context, id), duration = performance.now() - start;
                 if (this.loadTimings.set(plugin.name, (this.loadTimings.get(plugin.name) || 0) + duration), 'string' == typeof result) return result;
             }
             return null;
@@ -1019,8 +2133,8 @@ class RegisterHooksPlugin {
                 null !== loaded && this.lastLoadedModules.get(resolvedId) !== loaded && (this.lastLoadedModules.set(resolvedId, loaded), virtualModulesPlugin.writeModule(resolvedId, loaded));
             });
         }), compiler.hooks.compile.tap(registerHooks_PLUGIN_NAME, ()=>{
-            this.isCompiling = !0, this.resolveIdTimings.clear(), this.loadTimings.clear(), applyPluginsByHookSync('buildStart', (impl)=>{
-                impl({
+            this.isCompiling = !0, this.resolveIdTimings.clear(), this.loadTimings.clear(), applyPluginsByHookSync('buildStart', (impl, context)=>{
+                impl.call(context, {
                     compiler,
                     isFirstCompile: this.isFirstCompile,
                     isWatch: isDev()
@@ -1034,16 +2148,16 @@ class RegisterHooksPlugin {
             }
         };
         compiler.hooks.thisCompilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
-            applyPluginsByHookSync('processAssets', (impl, plugin)=>{
+            applyPluginsByHookSync('processAssets', (impl, context)=>{
                 let { stage, handler } = impl;
                 compilation.hooks.processAssets.tapPromise({
                     name: registerHooks_PLUGIN_NAME,
                     stage
                 }, async (assets)=>{
-                    let timer = createPluginHookTimer(plugin, 'processAssets');
+                    let timer = createPluginHookTimer(context.name, 'processAssets');
                     timer.start();
                     try {
-                        await handler({
+                        await handler.call(context, {
                             assets,
                             compilation,
                             sources: rspack.sources,
@@ -1055,8 +2169,8 @@ class RegisterHooksPlugin {
                 });
             });
         }), compiler.hooks.compilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
-            rspack.HtmlRspackPlugin.getCompilationHooks(compilation).beforeEmit.tapPromise(registerHooks_PLUGIN_NAME, async (data)=>(await applyPluginsByHook('transformHtml', async (impl)=>{
-                    let result = await impl(data.html);
+            rspack.HtmlRspackPlugin.getCompilationHooks(compilation).beforeEmit.tapPromise(registerHooks_PLUGIN_NAME, async (data)=>(await applyPluginsByHook('transformHtml', async (impl, context)=>{
+                    let result = await impl.call(context, data.html);
                     data.html = 'string' == typeof result ? result : applyHtmlTagDescriptors(data.html, result);
                 }), data));
         }), compiler.hooks.finishMake.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
@@ -1068,8 +2182,8 @@ class RegisterHooksPlugin {
                 transformTimingMap.delete(compilation);
             }
         }), compiler.hooks.done.tapPromise(registerHooks_PLUGIN_NAME, async (stats)=>{
-            await applyPluginsByHook('buildEnd', async (impl)=>{
-                await impl({
+            await applyPluginsByHook('buildEnd', async (impl, context)=>{
+                await impl.call(context, {
                     compiler,
                     isFirstCompile: this.isFirstCompile,
                     isWatch: isDev(),
@@ -1083,43 +2197,13 @@ class RegisterHooksPlugin {
         });
     }
 }
-async function applyTypeCheckConfig({ config, unpackConfig }) {
-    let { TsCheckerRspackPlugin } = await import("ts-checker-rspack-plugin"), tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json');
-    return config.plugins?.push(new TsCheckerRspackPlugin({
-        typescript: {
-            mode: 'readonly',
-            memoryLimit: 8192,
-            configFile: tsconfigPath,
-            typescriptPath: require.resolve("typescript", {
-                paths: [
-                    unpackConfig.root
-                ]
-            })
-        },
-        issue: {
-            exclude: [
-                ({ file = '' })=>NODE_MODULES_REGEX.test(file)
-            ]
-        },
-        logger: {
-            log (message) {
-                let count = +(/(\d+) errors?/.exec(message)?.[1] || 0);
-                count > 0 && console.log(`Found ${colors.red(colors.bold(`${count} ${1 === count ? 'error' : 'errors'}`))}`);
-            },
-            error (message) {
-                message.includes('RpcExitError') || message.includes('out of memory') || console.log(convertBasicAnsiColors(message.replace(/ERROR/g, 'Type Error')));
-            }
-        }
-    })), config;
-}
 var rspack_config_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 async function getRspackConfig(originalUnpackConfig) {
     setCurrentUnpackConfig(originalUnpackConfig);
     let { plugins, rspack: rspackConfig, ...rest } = originalUnpackConfig;
-    await applyPluginsByHook('config', async (impl)=>{
-        rest = await impl(rest, {
-            ...originalUnpackConfig._context,
-            mergeConfig: utils_mergeConfig
+    await applyPluginsByHook('config', async (impl, context)=>{
+        rest = await impl.call(context, rest, {
+            mergeConfig: dist_default()
         });
     });
     let unpackConfig = {
@@ -1127,10 +2211,16 @@ async function getRspackConfig(originalUnpackConfig) {
         plugins,
         rspack: rspackConfig
     };
-    setCurrentUnpackConfig(unpackConfig), await applyPluginsByHook('configResolved', async (impl)=>{
-        await impl(unpackConfig, originalUnpackConfig._context);
+    setCurrentUnpackConfig(unpackConfig), utils_isDevServer() && setDevServerPort(await getPort(unpackConfig.server?.port)), await applyPluginsByHook('configResolved', async (impl, context)=>{
+        await impl.call(context, unpackConfig);
     });
-    let tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTS = node_fs.existsSync(tsconfigPath), minifyOptions = isPlainObject(unpackConfig.build?.minify) ? unpackConfig.build?.minify : {}, { publicVars, filePaths: envFilePaths } = function({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
+    let tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTS = node_fs.existsSync(tsconfigPath), minifyOptions = isPlainObject(unpackConfig.build?.minify) ? unpackConfig.build?.minify : {}, publicDir = node_path.resolve(unpackConfig.root, 'public'), shouldCopyPublic = node_fs.existsSync(publicDir) && node_fs.statSync(publicDir).isDirectory() && node_fs.readdirSync(publicDir).length > 0, copyPatterns = [
+        ...unpackConfig.build?.copy || []
+    ];
+    shouldCopyPublic && copyPatterns.unshift({
+        from: publicDir
+    });
+    let { publicVars, filePaths: envFilePaths } = function({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
         'PUBLIC_'
     ], processEnv = process.env } = {}) {
         if ('local' === mode) throw Error(`${colors.yellow('local')} cannot be used as a value for env mode, because ${colors.yellow('.env.local')} represents a temporary local file. Please use another value.`);
@@ -1240,8 +2330,8 @@ async function getRspackConfig(originalUnpackConfig) {
                 ...publicVars,
                 ...unpackConfig.define
             }),
-            unpackConfig.build?.copy && new rspack.CopyRspackPlugin({
-                patterns: unpackConfig.build.copy
+            copyPatterns.length > 0 && new rspack.CopyRspackPlugin({
+                patterns: copyPatterns
             }),
             new RegisterHooksPlugin(),
             unpackConfig.build?.progressBar ? new ProgressPlugin() : new ProgressLitePlugin()
@@ -1286,16 +2376,8 @@ async function getRspackConfig(originalUnpackConfig) {
             moduleIds: isDev() ? 'named' : 'deterministic',
             minimize: !!unpackConfig.build?.minify && utils_isProd(),
             minimizer: [
-                new JsMinifyPlugin(utils_mergeConfig({
-                    compress: {
-                        target: unpackConfig.build.target
-                    }
-                }, minifyOptions.oxc || {})),
-                new rspack.LightningCssMinimizerRspackPlugin(utils_mergeConfig({
-                    minimizerOptions: {
-                        targets: esVersionToBrowserslist(unpackConfig.build.target)
-                    }
-                }, minifyOptions.lightningcss || {}))
+                new JsMinifyPlugin(minifyOptions.oxc),
+                new rspack.LightningCssMinimizerRspackPlugin(minifyOptions.lightningcss)
             ]
         },
         watchOptions: {
@@ -1305,7 +2387,7 @@ async function getRspackConfig(originalUnpackConfig) {
             hints: !1
         }
     };
-    return applyPluginsByHookSync('transform', (impl, plugin)=>{
+    return applyPluginsByHookSync('transform', (impl, context)=>{
         let { filter, handler } = impl;
         config.module.rules.unshift({
             exclude: NODE_MODULES_REGEX,
@@ -1315,8 +2397,8 @@ async function getRspackConfig(originalUnpackConfig) {
                 {
                     loader: node_path.resolve(rspack_config_dirname, './transformLoader.js'),
                     options: {
-                        handler,
-                        pluginName: plugin.name
+                        handler: (code, id)=>handler.call(context, code, id),
+                        pluginName: context.name
                     }
                 }
             ]
@@ -1367,15 +2449,15 @@ async function getRspackConfig(originalUnpackConfig) {
                 ]
             };
         };
-        return config.module.rules.push(createStyleRule(/\.css$/i, [
+        return config.module.rules.push(createStyleRule(CSS_REGEX, [
             getCssLoader(unpackConfig),
             unpackConfig.css?.tailwindcss && {
                 loader: require.resolve('@tailwindcss/webpack')
             }
-        ])), config.module.rules.push(createStyleRule(/\.less$/i, [
+        ])), config.module.rules.push(createStyleRule(LESS_REGEX, [
             getCssLoader(unpackConfig),
             getLessLoader(unpackConfig)
-        ])), config.module.rules.push(createStyleRule(/\.s[ac]ss$/i, [
+        ])), config.module.rules.push(createStyleRule(SASS_REGEX, [
             getCssLoader(unpackConfig),
             getSassLoader(unpackConfig)
         ])), config;
@@ -1421,7 +2503,7 @@ async function getRspackConfig(originalUnpackConfig) {
             }),
             ignoreOrder: !0
         })), config.module.rules.push({
-            test: /\.less$/i,
+            test: LESS_REGEX,
             use: [
                 ...getCommonRules({
                     importLoaders: 2
@@ -1430,7 +2512,7 @@ async function getRspackConfig(originalUnpackConfig) {
                 getLessLoader(unpackConfig)
             ]
         }), config.module.rules.push({
-            test: /\.css$/i,
+            test: CSS_REGEX,
             use: [
                 ...getCommonRules({
                     importLoaders: unpackConfig.css?.tailwindcss ? 2 : 1
@@ -1441,7 +2523,7 @@ async function getRspackConfig(originalUnpackConfig) {
                 }
             ].filter(Boolean)
         }), config.module.rules.push({
-            test: /\.s[ac]ss$/i,
+            test: SASS_REGEX,
             use: [
                 ...getCommonRules({
                     importLoaders: 2
@@ -1460,54 +2542,14 @@ async function getRspackConfig(originalUnpackConfig) {
         config,
         unpackConfig,
         envFilePaths
-    })), unpackConfig.performance?.buildAnalyze && utils_isProd() && (config = await applyBuildAnalyzeConfig({
-        config,
-        unpackConfig
-    })), unpackConfig.typeCheck && isDev() && isTS && (config = await applyTypeCheckConfig({
-        config,
-        unpackConfig
-    })), unpackConfig.detectCircular && (config = function({ config, unpackConfig }) {
-        let circularCount = 0, circularDependencyPlugin = new rspack.CircularDependencyRspackPlugin({
-            exclude: NODE_MODULES_REGEX,
-            onStart () {
-                circularCount = 0;
-            },
-            onDetected (_, modules) {
-                var paths;
-                let arrow, lastIndex;
-                circularCount++, logger_logger.warn('circular dependency detected:'), paths = modules.map((module)=>{
-                    let filePath = module.replace(/^.*!/, ''), relativePath = node_path.relative(unpackConfig.root, filePath);
-                    return relativePath.startsWith('..') ? filePath : relativePath;
-                }).slice(0, -1), console.log(''), arrow = colors.dim('↳ '), lastIndex = paths.length - 1, paths.forEach((p, i)=>{
-                    switch(i){
-                        case 0:
-                            console.log(`  ${p}`);
-                            break;
-                        case lastIndex:
-                            console.log(`  ${arrow}${p} ${colors.yellow(colors.dim('(cycle introduced)'))}`);
-                            break;
-                        default:
-                            console.log(`  ${arrow}${p}`);
-                    }
-                }), console.log(`  ${arrow}${paths[0]}`), console.log('');
-            },
-            onEnd () {
-                circularCount > 0 && console.log('Found', colors.yellow(colors.bold(`${circularCount} circular ${1 === circularCount ? 'dependency' : 'dependencies'}`)));
-            }
-        });
-        return config.plugins?.push(circularDependencyPlugin), config;
-    }({
-        config,
-        unpackConfig
-    })), await applyPluginsByHook('rspackConfig', async (impl)=>{
-        config = await impl(config, {
-            ...originalUnpackConfig._context,
+    })), await applyPluginsByHook('rspackConfig', async (impl, context)=>{
+        config = await impl.call(context, config, {
             unpackConfig,
-            mergeConfig: utils_mergeConfig
+            mergeConfig: dist_default()
         });
     }), unpackConfig.rspack && (config = isFunction(unpackConfig.rspack) ? await unpackConfig.rspack(config, {
-        mergeConfig: utils_mergeConfig
-    }) : utils_mergeConfig(config, unpackConfig.rspack)), config;
+        mergeConfig: dist_default()
+    }) : dist_default()(config, unpackConfig.rspack)), config;
 }
 async function unpackBuild(unpackConfig) {
     let compiler = rspack(await getRspackConfig(unpackConfig)), handler = (err, stats)=>{
@@ -1585,8 +2627,8 @@ function execAsync(command, options) {
         });
     });
 }
-async function unpackDev(unpackConfig) {
-    let compiler = rspack(await getRspackConfig(unpackConfig)), port = await getPort(unpackConfig.server?.port), proxyConfig = unpackConfig.server?.proxy;
+async function unpackDev(originalConfig) {
+    let config = await getRspackConfig(originalConfig), unpackConfig = getCurrentUnpackConfig(), compiler = rspack(config), port = getDevServerPort(), proxyConfig = unpackConfig.server?.proxy;
     isPlainObject(proxyConfig) && (proxyConfig = Object.entries(proxyConfig).map(([contextStr, target])=>{
         let baseConfig = {
             context: contextStr.split(','),
@@ -1614,8 +2656,8 @@ async function unpackDev(unpackConfig) {
         },
         host: unpackConfig.server?.host ? ALL_INTERFACES_IPV4 : LOCALHOST
     }, pluginMiddlewares = [];
-    await applyPluginsByHook('setupMiddlewares', async (impl)=>{
-        pluginMiddlewares = await impl(pluginMiddlewares);
+    await applyPluginsByHook('setupMiddlewares', async (impl, context)=>{
+        pluginMiddlewares = await impl.call(context, pluginMiddlewares);
     }), devServerOptions.setupMiddlewares = (middlewares)=>(middlewares.unshift((req, _, next)=>{
             let accept = req.headers.accept;
             if ('string' == typeof accept && accept.includes('html')) {
@@ -1628,7 +2670,7 @@ async function unpackDev(unpackConfig) {
             ...middlewares
         ]);
     let server = new RspackDevServer(devServerOptions, compiler);
-    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v4.6.1`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
+    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v4.7.1`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
         port,
         host: unpackConfig.server.host,
         base: unpackConfig.base
@@ -1642,10 +2684,10 @@ async function unpackDev(unpackConfig) {
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "4.6.1",
+        version: "4.7.1",
         cachePath: 'node_modules/.unpack'
     }, resolveConfig = (mode)=>{
-        let rootPath, outputPath, basePath, cachedTraceMap, fs, isValidMethodName, parseFrame, formatOriginalLocation, formatFullStack, resolveErrorLocationAndStack, root, alias, shouldTransformDeepImport, preJsAssets, jsAssets, cssAssets, bundledDepsCachePath, deepImportPkgPattern, deepImportRegex, plugin, root1, uno, generated, configOrPathFromUnpackConfig, defaultsFromUnpackConfig, VIRTUAL_UNO_CSS_ID, rootDir, isMpa, unoConfig, configFilePath, unpackConfigPath, tokens, requestedLayers, tasks, unocssCacheDir, tokensCachePath, layersCachePath, timeCachePath, configHashCachePath, generatedCachePath, bundlerCacheDir, cachedTokensSize, cachedLayersSize, isCompiling, resolveUnocssConfig, flushTasks, getVirtualModuleContent, hash, restoreSkipCode, applyUnoTransformers, optionsFromUnpackConfig, rootPath1, registerCode, namesCode, defaultConfig = {
+        let rootPath, outputPath, basePath, cachedTraceMap, fs, isValidMethodName, parseFrame, formatOriginalLocation, formatFullStack, resolveErrorLocationAndStack, root, alias, shouldTransformDeepImport, preJsAssets, jsAssets, cssAssets, bundledDepsCachePath, deepImportPkgPattern, deepImportRegex, plugin, tsconfigPath, root1, uno, generated, configOrPath, defaults, VIRTUAL_UNO_CSS_ID, rootDir, isMpa, unoConfig, configFilePath, unpackConfigPath, tokens, requestedLayers, tasks, unocssCacheDir, tokensCachePath, layersCachePath, timeCachePath, configHashCachePath, generatedCachePath, bundlerCacheDir, cachedTokensSize, cachedLayersSize, isCompiling, resolveUnocssConfig, flushTasks, getVirtualModuleContent, hash, restoreSkipCode, applyUnoTransformers, options, rootPath1, registerCode, namesCode, defaultConfig = {
             root: cwd,
             base: '/',
             sourceMap: 'production' !== mode && 'cheap-module-source-map',
@@ -1878,79 +2920,76 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
 `
                             }
                         ],
-                    setupMiddlewares: (middlewares)=>[
-                            (req, res, next)=>{
-                                if ('POST' !== req.method || !req.url?.startsWith(BROWSER_LOGS_ENDPOINT)) return next();
-                                let raw = '';
-                                req.on('data', (chunk)=>{
-                                    raw += chunk.toString();
-                                }), req.on('end', async ()=>{
-                                    try {
-                                        let { level, time, args = [] } = JSON.parse(raw || '{}'), formattedArgs = await Promise.all(args.map(async (item)=>{
-                                            if (!item) return '';
-                                            if ('error' === item.type) {
-                                                let { locationSuffix, stackString } = await resolveErrorLocationAndStack(item), msg = item.message || '', suffix = locationSuffix ? msg ? ` ${locationSuffix}` : locationSuffix : '';
-                                                return `${msg}${suffix}${stackString}`;
+                    setupMiddlewares: (middlewares)=>(middlewares.unshift((req, res, next)=>{
+                            if ('POST' !== req.method || !req.url?.startsWith(BROWSER_LOGS_ENDPOINT)) return next();
+                            let raw = '';
+                            req.on('data', (chunk)=>{
+                                raw += chunk.toString();
+                            }), req.on('end', async ()=>{
+                                try {
+                                    let { level, time, args = [] } = JSON.parse(raw || '{}'), formattedArgs = await Promise.all(args.map(async (item)=>{
+                                        if (!item) return '';
+                                        if ('error' === item.type) {
+                                            let { locationSuffix, stackString } = await resolveErrorLocationAndStack(item), msg = item.message || '', suffix = locationSuffix ? msg ? ` ${locationSuffix}` : locationSuffix : '';
+                                            return `${msg}${suffix}${stackString}`;
+                                        }
+                                        switch(item.type){
+                                            case 'string':
+                                                let trimmed;
+                                                return (trimmed = item.message.trim()) ? trimmed.split(/\r?\n/g).filter((line)=>{
+                                                    let normalized = line.trim().replace(/`/g, '');
+                                                    return !!normalized && !/^at\s+/.test(normalized);
+                                                }).join('\n').trim() : '';
+                                            case 'null':
+                                                return null;
+                                            case 'undefined':
+                                                return;
+                                            case 'object':
+                                                return JSON.parse(item.message || '');
+                                            default:
+                                                return item.message;
+                                        }
+                                    })), outputArgs = ((args)=>{
+                                        if (args.length < 2 || 'string' != typeof args[0]) return args;
+                                        let template = args[0];
+                                        if (!/%[sdifoOj%c%]/.test(template)) return args;
+                                        let rest = args.slice(1), cleanedTemplate = '';
+                                        for(let i = 0; i < template.length; i++){
+                                            let ch = template[i];
+                                            if ('%' !== ch || i + 1 >= template.length) {
+                                                cleanedTemplate += ch;
+                                                continue;
                                             }
-                                            switch(item.type){
-                                                case 'string':
-                                                    let trimmed;
-                                                    return (trimmed = item.message.trim()) ? trimmed.split(/\r?\n/g).filter((line)=>{
-                                                        let normalized = line.trim().replace(/`/g, '');
-                                                        return !!normalized && !/^at\s+/.test(normalized);
-                                                    }).join('\n').trim() : '';
-                                                case 'null':
-                                                    return null;
-                                                case 'undefined':
-                                                    return;
-                                                case 'object':
-                                                    return JSON.parse(item.message || '');
-                                                default:
-                                                    return item.message;
+                                            let next = template[i + 1];
+                                            if ('%' === next) {
+                                                cleanedTemplate += '%%', i++;
+                                                continue;
                                             }
-                                        })), outputArgs = ((args)=>{
-                                            if (args.length < 2 || 'string' != typeof args[0]) return args;
-                                            let template = args[0];
-                                            if (!/%[sdifoOj%c%]/.test(template)) return args;
-                                            let rest = args.slice(1), cleanedTemplate = '';
-                                            for(let i = 0; i < template.length; i++){
-                                                let ch = template[i];
-                                                if ('%' !== ch || i + 1 >= template.length) {
-                                                    cleanedTemplate += ch;
-                                                    continue;
-                                                }
-                                                let next = template[i + 1];
-                                                if ('%' === next) {
-                                                    cleanedTemplate += '%%', i++;
-                                                    continue;
-                                                }
-                                                if ('c' === next) {
-                                                    rest.length > 0 && rest.shift(), i++;
-                                                    continue;
-                                                }
-                                                cleanedTemplate += `%${next}`, i++;
+                                            if ('c' === next) {
+                                                rest.length > 0 && rest.shift(), i++;
+                                                continue;
                                             }
-                                            return [
-                                                format(cleanedTemplate, ...rest)
-                                            ];
-                                        })(formattedArgs), prefix = colors.dim(`[browser ${time}]`);
-                                        switch(level){
-                                            case 'error':
-                                                console.log(colors.red(`${prefix} ${format(...outputArgs)}`));
-                                                break;
-                                            case 'warn':
-                                                console.log(colors.yellow(`${prefix} ${format(...outputArgs)}`));
-                                                break;
-                                            case 'debug':
-                                                console.log(prefix, ...outputArgs);
+                                            cleanedTemplate += `%${next}`, i++;
                                         }
-                                    } finally{
-                                        res.statusCode = 204, res.end();
+                                        return [
+                                            format(cleanedTemplate, ...rest)
+                                        ];
+                                    })(formattedArgs), prefix = colors.dim(`[browser ${time}]`);
+                                    switch(level){
+                                        case 'error':
+                                            console.log(colors.red(`${prefix} ${format(...outputArgs)}`));
+                                            break;
+                                        case 'warn':
+                                            console.log(colors.yellow(`${prefix} ${format(...outputArgs)}`));
+                                            break;
+                                        case 'debug':
+                                            console.log(prefix, ...outputArgs);
                                     }
-                                });
-                            },
-                            ...middlewares
-                        ]
+                                } finally{
+                                    res.statusCode = 204, res.end();
+                                }
+                            });
+                        }), middlewares)
                 }),
                 (root = '', alias = {}, {
                     name: 'unpack:glob',
@@ -2040,14 +3079,14 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                 ].sort((a, b)=>b.length - a.length).map((name)=>name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), deepImportRegex = RegExp(`import\\s+([a-zA-Z0-9_$]+)\\s+from\\s+['"]((${deepImportPkgPattern})/[^'"]+)['"]`, 'g'), plugin = {
                     name: 'unpack:prebundle',
                     apply: (config, { command })=>'dev' === command && !!config.dev?.prebundle,
-                    config: async (config, context)=>{
+                    async config (config) {
                         var externals;
                         let existExternals, root = config.root;
-                        bundledDepsCachePath = node_path.resolve(root, context.cachePath, 'umd');
+                        bundledDepsCachePath = node_path.resolve(root, this.cachePath, 'umd');
                         let count = {
                             total: 0,
                             bundled: 0
-                        }, failedDepsJsonPath = node_path.resolve(root, context.cachePath, 'failed-deps.json'), failedDeps = [], failedCache = node_fs.existsSync(failedDepsJsonPath) ? JSON.parse(node_fs.readFileSync(failedDepsJsonPath, 'utf-8')) : {}, updateProgress = ()=>{
+                        }, failedDepsJsonPath = node_path.resolve(root, this.cachePath, 'failed-deps.json'), failedDeps = [], failedCache = node_fs.existsSync(failedDepsJsonPath) ? JSON.parse(node_fs.readFileSync(failedDepsJsonPath, 'utf-8')) : {}, updateProgress = ()=>{
                             let errMsg = failedDeps.length > 0 ? ` failed: ${failedDeps.join(', ')}` : '';
                             logUpdate(`${colors.magenta('»')} optimizing dependencies (${count.bundled}/${count.total})${errMsg}`), count.total === count.bundled + failedDeps.length && console.log();
                         }, userOptions = isPlainObject(config.dev?.prebundle) ? config.dev.prebundle : {}, ignoreCSSDeps = userOptions.ignoreCSS || [], packageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'package.json'), 'utf-8')), excludeDeps = [
@@ -2188,7 +3227,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                                     ]
                                                 },
                                                 {
-                                                    test: /\.less$/,
+                                                    test: LESS_REGEX,
                                                     type: 'css/auto',
                                                     use: [
                                                         {
@@ -2203,7 +3242,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                                     ]
                                                 },
                                                 {
-                                                    test: /\.s[ac]ss$/i,
+                                                    test: SASS_REGEX,
                                                     type: 'css/auto',
                                                     use: [
                                                         {
@@ -2217,6 +3256,10 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                                             }
                                                         }
                                                     ]
+                                                },
+                                                {
+                                                    test: CSS_REGEX,
+                                                    type: 'css/auto'
                                                 }
                                             ]
                                         },
@@ -2281,29 +3324,26 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                     src
                                 }
                             })),
-                    setupMiddlewares: (middlewares)=>[
-                            (req, res, next)=>{
-                                if ('string' != typeof req.url) return void next();
-                                let url = new URL(req.url, 'http://localhost');
-                                if (!url.pathname.startsWith("/umd/")) return void next();
-                                let relativePath = url.pathname.replace("/umd/", '');
-                                if (relativePath.includes('..')) {
-                                    res.statusCode = 403, res.end();
-                                    return;
-                                }
-                                let filePath = node_path.join(bundledDepsCachePath, relativePath);
-                                if (!node_fs.existsSync(filePath)) return void next();
-                                let stat = node_fs.statSync(filePath);
-                                if (!stat.isFile()) return void next();
-                                let mtime = stat.mtime.toUTCString(), ext = node_path.extname(filePath);
-                                if (res.setHeader('Cache-Control', 'no-cache'), res.setHeader('Last-Modified', mtime), '.js' === ext && res.setHeader('Content-Type', "application/javascript"), '.css' === ext && res.setHeader('Content-Type', 'text/css'), req.headers['if-modified-since'] === mtime) {
-                                    res.statusCode = 304, res.end();
-                                    return;
-                                }
-                                res.statusCode = 200, node_fs.createReadStream(filePath).pipe(res);
-                            },
-                            ...middlewares
-                        ],
+                    setupMiddlewares: (middlewares)=>(middlewares.unshift((req, res, next)=>{
+                            if ('string' != typeof req.url) return void next();
+                            let url = new URL(req.url, 'http://localhost');
+                            if (!url.pathname.startsWith("/umd/")) return void next();
+                            let relativePath = url.pathname.replace("/umd/", '');
+                            if (relativePath.includes('..')) {
+                                res.statusCode = 403, res.end();
+                                return;
+                            }
+                            let filePath = node_path.join(bundledDepsCachePath, relativePath);
+                            if (!node_fs.existsSync(filePath)) return void next();
+                            let stat = node_fs.statSync(filePath);
+                            if (!stat.isFile()) return void next();
+                            let mtime = stat.mtime.toUTCString(), ext = node_path.extname(filePath);
+                            if (res.setHeader('Cache-Control', 'no-cache'), res.setHeader('Last-Modified', mtime), '.js' === ext && res.setHeader('Content-Type', "application/javascript"), '.css' === ext && res.setHeader('Content-Type', 'text/css'), req.headers['if-modified-since'] === mtime) {
+                                res.statusCode = 304, res.end();
+                                return;
+                            }
+                            res.statusCode = 200, node_fs.createReadStream(filePath).pipe(res);
+                        }), middlewares),
                     rspackConfig: (config)=>{
                         let PLUGIN_NAME = 'InjectAssetsPlugin';
                         return config.plugins.push({
@@ -2315,6 +3355,92 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                         }), config;
                     }
                 }),
+                {
+                    name: 'unpack:type-check',
+                    apply: (config, { command })=>(tsconfigPath = node_path.resolve(config.root, 'tsconfig.json'), node_fs.existsSync(tsconfigPath) && 'dev' === command && config.typeCheck),
+                    async rspackConfig (config, { unpackConfig }) {
+                        let { TsCheckerRspackPlugin } = await import("ts-checker-rspack-plugin");
+                        return config.plugins.push(new TsCheckerRspackPlugin({
+                            typescript: {
+                                mode: 'readonly',
+                                memoryLimit: 8192,
+                                configFile: tsconfigPath,
+                                typescriptPath: require.resolve("typescript", {
+                                    paths: [
+                                        unpackConfig.root
+                                    ]
+                                })
+                            },
+                            issue: {
+                                exclude: [
+                                    ({ file = '' })=>NODE_MODULES_REGEX.test(file)
+                                ]
+                            },
+                            logger: {
+                                log (message) {
+                                    let count = +(/(\d+) errors?/.exec(message)?.[1] || 0);
+                                    count > 0 && console.log(`Found ${colors.red(colors.bold(`${count} ${1 === count ? 'error' : 'errors'}`))}`);
+                                },
+                                error (message) {
+                                    message.includes('RpcExitError') || message.includes('out of memory') || console.log(convertBasicAnsiColors(message.replace(/ERROR/g, 'Type Error')));
+                                }
+                            }
+                        })), config;
+                    }
+                },
+                {
+                    name: 'unpack:target',
+                    rspackConfig: (config)=>(config.target = 'browserslist', config),
+                    configResolved (config) {
+                        let root = config.root, packageJsonPath = node_path.join(root, 'package.json');
+                        if (!node_fs.existsSync(packageJsonPath) || BROWSERSLIST_CONFIG_FILES.some((file)=>node_fs.existsSync(node_path.join(root, file)))) return;
+                        let packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+                        'browserslist' in packageJson || (packageJson.browserslist = esVersionToBrowserslist(config.build.target), node_fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`));
+                    }
+                },
+                {
+                    name: 'unpack:build-analyze',
+                    apply: (config, { command })=>'build' === command && config.performance?.buildAnalyze,
+                    async rspackConfig (config) {
+                        let { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
+                        return config.plugins.push(new RsdoctorRspackPlugin()), config.devtool = 'source-map', config;
+                    }
+                },
+                {
+                    name: 'unpack:detect-circular',
+                    apply: (config)=>config.detectCircular,
+                    rspackConfig (config, { unpackConfig }) {
+                        let circularCount = 0;
+                        return config.plugins.push(new rspack.CircularDependencyRspackPlugin({
+                            exclude: NODE_MODULES_REGEX,
+                            onStart () {
+                                circularCount = 0;
+                            },
+                            onDetected (_, modules) {
+                                var paths;
+                                let arrow, lastIndex;
+                                circularCount++, logger_logger.warn('circular dependency detected:'), paths = modules.map((module)=>{
+                                    let filePath = module.replace(/^.*!/, ''), relativePath = node_path.relative(unpackConfig.root, filePath);
+                                    return relativePath.startsWith('..') ? filePath : relativePath;
+                                }).slice(0, -1), console.log(''), arrow = colors.dim('↳ '), lastIndex = paths.length - 1, paths.forEach((p, i)=>{
+                                    switch(i){
+                                        case 0:
+                                            console.log(`  ${p}`);
+                                            break;
+                                        case lastIndex:
+                                            console.log(`  ${arrow}${p} ${colors.yellow(colors.dim('(cycle introduced)'))}`);
+                                            break;
+                                        default:
+                                            console.log(`  ${arrow}${p}`);
+                                    }
+                                }), console.log(`  ${arrow}${paths[0]}`), console.log('');
+                            },
+                            onEnd () {
+                                circularCount > 0 && console.log('Found', colors.yellow(colors.bold(`${circularCount} circular ${1 === circularCount ? 'dependency' : 'dependencies'}`)));
+                            }
+                        })), config;
+                    }
+                },
                 (root1 = '', {
                     name: 'unpack:file-size',
                     apply: (config, { mode })=>'production' === mode && config.performance?.printFileSize,
@@ -2390,8 +3516,8 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                 (VIRTUAL_UNO_CSS_ID = 'uno.css', rootDir = process.cwd(), isMpa = !1, unoConfig = {}, configFilePath = '', unpackConfigPath = '', tokens = new Set(), requestedLayers = new Set([
                     LAYER_MARK_ALL
                 ]), tasks = [], unocssCacheDir = '', tokensCachePath = '', layersCachePath = '', timeCachePath = '', configHashCachePath = '', generatedCachePath = '', bundlerCacheDir = '', cachedTokensSize = 0, cachedLayersSize = 0, isCompiling = !0, resolveUnocssConfig = async ()=>{
-                    let resolvedConfigOrPath = (void 0) ?? configOrPathFromUnpackConfig, resolvedDefaults = (void 0) ?? defaultsFromUnpackConfig, configFromOption = {};
-                    return isPlainObject(resolvedConfigOrPath) ? configFromOption = resolvedConfigOrPath : isString(resolvedConfigOrPath) && (configFilePath = node_path.isAbsolute(resolvedConfigOrPath) ? resolvedConfigOrPath : node_path.resolve(rootDir, resolvedConfigOrPath)), configFilePath = ((root, customConfig)=>{
+                    let configFromOption = {};
+                    isPlainObject(configOrPath) ? configFromOption = configOrPath : isString(configOrPath) && (configFilePath = node_path.isAbsolute(configOrPath) ? configOrPath : node_path.resolve(rootDir, configOrPath)), configFilePath = ((root, customConfig)=>{
                         if (customConfig) {
                             let absPath = node_path.isAbsolute(customConfig) ? customConfig : node_path.resolve(root, customConfig);
                             if (node_fs.existsSync(absPath)) return absPath;
@@ -2400,7 +3526,9 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                             let configFile = node_path.join(root, file);
                             if (node_fs.existsSync(configFile)) return configFile;
                         }
-                    })(rootDir, configFilePath), configFromOption = utils_mergeConfig(configFromOption, await loadConfigFromFile(configFilePath)), resolvedDefaults && (configFromOption = utils_mergeConfig(resolvedDefaults, configFromOption)), configFromOption;
+                    })(rootDir, configFilePath);
+                    let loaded = await loadConfigFromFile(configFilePath);
+                    return configFromOption = dist_default()(configFromOption, loaded), defaults && (configFromOption = dist_default()(defaults, configFromOption)), configFromOption;
                 }, flushTasks = async ()=>{
                     if (!tasks.length) return;
                     logger_logger.debug(colors.yellow(`[unocss] Extract token from ${tasks.length} modules.`));
@@ -2438,10 +3566,10 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                 }, {
                     name: 'unpack:unocss',
                     apply: (config)=>!!config.css?.unocss,
-                    configResolved: async (config, { cachePath })=>{
-                        if (rootDir = config.root, isMpa = !!config.mpa, unpackConfigPath = resolveConfigPath(rootDir), bundlerCacheDir = node_path.resolve(rootDir, cachePath, 'cache'), unocssCacheDir = node_path.resolve(rootDir, cachePath, 'unocss'), tokensCachePath = node_path.resolve(unocssCacheDir, 'tokens'), layersCachePath = node_path.resolve(unocssCacheDir, 'layers'), timeCachePath = node_path.resolve(unocssCacheDir, 'created_at'), configHashCachePath = node_path.resolve(unocssCacheDir, 'config_hash'), generatedCachePath = node_path.resolve(unocssCacheDir, 'generated'), Array.isArray(config.css?.unocss)) {
+                    async configResolved (config) {
+                        if (rootDir = config.root, isMpa = !!config.mpa, unpackConfigPath = resolveConfigPath(rootDir), bundlerCacheDir = node_path.resolve(rootDir, this.cachePath, 'cache'), unocssCacheDir = node_path.resolve(rootDir, this.cachePath, 'unocss'), tokensCachePath = node_path.resolve(unocssCacheDir, 'tokens'), layersCachePath = node_path.resolve(unocssCacheDir, 'layers'), timeCachePath = node_path.resolve(unocssCacheDir, 'created_at'), configHashCachePath = node_path.resolve(unocssCacheDir, 'config_hash'), generatedCachePath = node_path.resolve(unocssCacheDir, 'generated'), Array.isArray(config.css?.unocss)) {
                             let [configOrPathValue, defaultsValue] = config.css.unocss;
-                            configOrPathFromUnpackConfig = configOrPathValue, defaultsFromUnpackConfig = defaultsValue;
+                            configOrPath = configOrPathValue, defaults = defaultsValue;
                         }
                         unoConfig = await resolveUnocssConfig();
                         let core = await import("@unocss/core");
@@ -2549,8 +3677,8 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     name: 'unpack:svg-icons',
                     apply: (config)=>!!config.svgIcons,
                     configResolved: (config)=>{
-                        rootPath1 = config.root || process.cwd(), optionsFromUnpackConfig = config.svgIcons, (()=>{
-                            let root, resolvedOptions = (void 0) ?? optionsFromUnpackConfig, inject = resolvedOptions.inject || 'body-last', domId = resolvedOptions.customDomId || '__svg__icons__dom__', { svg, names } = ((iconDirs, symbolId, customDomId)=>{
+                        rootPath1 = config.root || process.cwd(), options = config.svgIcons, (()=>{
+                            let root, inject = options.inject || 'body-last', domId = options.customDomId || '__svg__icons__dom__', { svg, names } = ((iconDirs, symbolId, customDomId)=>{
                                 let symbols = [], names = [], idSet = new Set();
                                 for (let dir of iconDirs)for (let file of readSvgFiles(dir)){
                                     let { inner, viewBox } = extractSvgContent(normalizeSvg(node_fs.readFileSync(file, 'utf-8'))), id = toSymbolId(file, dir, symbolId);
@@ -2560,7 +3688,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                     svg: `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" id="${customDomId}" style="position: absolute; width: 0; height: 0" aria-hidden="true">${symbols.join('')}</svg>`,
                                     names
                                 };
-                            })((root = rootPath1, (resolvedOptions.iconDirs || []).map((dir)=>node_path.isAbsolute(dir) ? dir : node_path.resolve(root, dir))), resolvedOptions.symbolId, domId);
+                            })((root = rootPath1, (options.iconDirs || []).map((dir)=>node_path.isAbsolute(dir) ? dir : node_path.resolve(root, dir))), options.symbolId, domId);
                             registerCode = `const svgDomId = ${JSON.stringify(domId)}\nconst svgHtml = ${JSON.stringify(svg)}\nconst inject = (position) => {\n  if (typeof document === 'undefined') return\n  if (document.getElementById(svgDomId)) return\n  const div = document.createElement('div')\n  div.innerHTML = svgHtml\n  const svgEl = div.firstElementChild\n  if (!svgEl) return\n  if (position === 'head' && document.head) {\n    document.head.prepend(svgEl)\n    return\n  }\n  const body = document.body\n  if (!body) return\n  if (position === 'body-first' && body.firstChild) {\n    body.insertBefore(svgEl, body.firstChild)\n  } else {\n    body.appendChild(svgEl)\n  }\n}\nconst mount = () => inject(${JSON.stringify(inject)})\nif (typeof document !== 'undefined') {\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', mount)\n  } else {\n    mount()\n  }\n}\nexport default mount`, namesCode = `export const svgIconNames = ${JSON.stringify(names)}\nexport default svgIconNames`;
                         })();
                     },
@@ -2626,7 +3754,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
             ]
         };
         return {
-            ...utils_mergeConfig(defaultConfig, userConfig),
+            ...dist_default()(defaultConfig, userConfig),
             _context
         };
     };
@@ -2635,7 +3763,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
             let mode = watch ? 'development' : 'production';
             setNodeEnv(mode);
             let config = resolveConfig(mode);
-            console.log(colors.brand(`${callerName} v4.6.1`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v4.7.1`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
             setUnpackStartTime(performance.now());
@@ -2664,14 +3792,17 @@ async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
     });
 }
 var injectFramework_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-async function injectFrameworkPluginForDebug(userConfig) {
-    var plugin;
-    let framework = process.env.FRAMEWORK?.trim();
-    if (!framework) return;
-    let pluginPath = node_path.resolve(injectFramework_dirname, `../../plugin-${framework}/dist/index.js`);
-    node_fs.existsSync(pluginPath) && (plugin = (0, (await import(pluginPath))[`plugin${framework.charAt(0).toUpperCase() + framework.slice(1)}`])(), userConfig.plugins ? userConfig.plugins.unshift(plugin) : userConfig.plugins = [
+let injectPlugin = (userConfig, plugin)=>{
+    userConfig.plugins ? userConfig.plugins.unshift(plugin) : userConfig.plugins = [
         plugin
-    ]);
+    ];
+};
+async function injectFrameworkPluginForDebug(userConfig) {
+    let frameworkEnv = process.env.FRAMEWORK?.trim();
+    if (frameworkEnv) for (let framework of frameworkEnv.split(',').map((item)=>item.trim()).filter(Boolean)){
+        let pluginPath = node_path.resolve(injectFramework_dirname, `../../plugin-${framework}/dist/index.js`);
+        if (node_fs.existsSync(pluginPath)) injectPlugin(userConfig, (0, (await import(pluginPath))[`plugin${framework.charAt(0).toUpperCase() + framework.slice(1)}`])());
+    }
 }
 async function setupCliShortcuts({ help = !0, openPage, closeServer, printUrls, restartServer }) {
     let shortcuts = [
@@ -2786,7 +3917,8 @@ function runCLI() {
             logger_logger.clear(), logger_logger.info(`${node_path.basename(file)} changed, restarting server...`), await watcher.close(), await cleanUpBeforeRestart(), startServer(options);
         });
     });
-    devCommand.option('-o, --open [url]', 'Open browser on startup').option('--port <port>', 'Specify port').option('--host', 'Expose hostname').action(startServer), cli.help(), cli.version("4.6.1"), cli.parse();
+    devCommand.option('-o, --open [url]', 'Open browser on startup').option('--port <port>', 'Specify port').option('--host', 'Expose hostname').action(startServer), cli.help(), cli.version("4.7.1"), cli.parse();
 }
-var src_CSS_MODULES_NAMED_EXPORT = !1;
-export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, applyHtmlTagDescriptors, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, emptyDir, ensureDir, esVersionToBrowserslist, external_tinyglobby_glob as glob, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getFilesContentHash, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, isBoolean, isDebug, isDev, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launchEditor, loadConfig, loadConfigFromFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, normalizePublicPath, openBrowser, pLimit, pathExists, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, renderHtmlTagDescriptor, resolveConfigPath, rspack, runCLI, set, setCurrentUnpackConfig, setDevServer, setNodeEnv, setUnpackStartTime, src_CSS_MODULES_NAMED_EXPORT as CSS_MODULES_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd, utils_mergeConfig as mergeConfig };
+let launch_editor = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/index.js");
+var launch_editor_default_0 = __webpack_require__.n(launch_editor)(), src_CSS_MODULES_NAMED_EXPORT = !1;
+export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, CSS_REGEX, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LESS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SASS_REGEX, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, applyHtmlTagDescriptors, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, dist_default_0 as mergeConfig, emptyDir, ensureDir, esVersionToBrowserslist, external_tinyglobby_glob as glob, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getDevServerPort, getFilesContentHash, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, isBoolean, isDebug, isDev, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launch_editor_default_0 as launchEditor, loadConfig, loadConfigFromFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, normalizePublicPath, openBrowser, pLimit, pathExists, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, renderHtmlTagDescriptor, resolveConfigPath, rspack, runCLI, set, setCurrentUnpackConfig, setDevServer, setDevServerPort, setNodeEnv, setUnpackStartTime, src_CSS_MODULES_NAMED_EXPORT as CSS_MODULES_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd };