@rspack/dev-server 2.0.2 → 2.1.0

package/dist/0~launch-editor.js

@@ -0,0 +1,649 @@
+import { __webpack_require__ } from "./944.js";
+import "./944.js";
+__webpack_require__.add({
+    "./node_modules/.pnpm/launch-editor@2.14.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.14.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/Code': 'code',
+            '/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.14.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.14.1/node_modules/launch-editor/get-args.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        module.exports = function(editor, fileName, lineNumber, columnNumber = 1) {
+            const editorBasename = path.basename(editor).replace(/\.(exe|cmd|bat)$/i, '');
+            switch(editorBasename){
+                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
+                    ];
+            }
+            if (process.env.LAUNCH_EDITOR) return [
+                fileName,
+                lineNumber,
+                columnNumber
+            ];
+            return [
+                fileName
+            ];
+        };
+    },
+    "./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/guess.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const shellQuote = __webpack_require__("./node_modules/.pnpm/shell-quote@1.8.4/node_modules/shell-quote/index.js");
+        const childProcess = __webpack_require__("child_process");
+        const COMMON_EDITORS_MACOS = __webpack_require__("./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/editor-info/macos.js");
+        const COMMON_EDITORS_LINUX = __webpack_require__("./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/editor-info/linux.js");
+        const COMMON_EDITORS_WIN = __webpack_require__("./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/editor-info/windows.js");
+        function getEditorFromMacProcesses(output) {
+            const processNames = Object.keys(COMMON_EDITORS_MACOS);
+            const processList = output.split('\n');
+            for(let i = 0; i < processNames.length; i++){
+                const processName = processNames[i];
+                if (processList.includes(processName)) return COMMON_EDITORS_MACOS[processName];
+                const processNameWithoutApplications = processName.replace('/Applications', '');
+                if (-1 !== output.indexOf(processNameWithoutApplications)) {
+                    if (processName !== COMMON_EDITORS_MACOS[processName]) return COMMON_EDITORS_MACOS[processName];
+                    const runningProcess = processList.find((procName)=>procName.endsWith(processNameWithoutApplications));
+                    if (void 0 !== runningProcess) return runningProcess;
+                }
+            }
+        }
+        function getEditorFromWindowsProcesses(output) {
+            const runningProcesses = output.split('\r\n');
+            for(let i = 0; i < runningProcesses.length; i++){
+                const fullProcessPath = runningProcesses[i].trim();
+                const shortProcessName = path.win32.basename(fullProcessPath);
+                if (-1 !== COMMON_EDITORS_WIN.indexOf(shortProcessName)) return fullProcessPath;
+            }
+        }
+        function getEditorFromLinuxProcesses(output) {
+            const processNames = Object.keys(COMMON_EDITORS_LINUX);
+            for(let i = 0; i < processNames.length; i++){
+                const processName = processNames[i];
+                if (-1 !== output.indexOf(processName)) return COMMON_EDITORS_LINUX[processName];
+            }
+        }
+        function guessEditor(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) {
+                    const output = childProcess.execSync('ps x -o comm=', {
+                        stdio: [
+                            'pipe',
+                            'pipe',
+                            'ignore'
+                        ]
+                    }).toString();
+                    const editor = getEditorFromMacProcesses(output);
+                    if (void 0 !== editor) return [
+                        editor
+                    ];
+                } else if ('win32' === process.platform) {
+                    const output = 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();
+                    const editor = getEditorFromWindowsProcesses(output);
+                    if (void 0 !== editor) return [
+                        editor
+                    ];
+                } else if ('linux' === process.platform) {
+                    const output = childProcess.execSync('ps x --no-heading -o comm --sort=comm', {
+                        stdio: [
+                            'pipe',
+                            'pipe',
+                            'ignore'
+                        ]
+                    }).toString();
+                    const editor = getEditorFromLinuxProcesses(output);
+                    if (void 0 !== editor) return [
+                        editor
+                    ];
+                }
+            } catch (ignoreError) {}
+            if (process.env.VISUAL) return [
+                process.env.VISUAL
+            ];
+            if (process.env.EDITOR) return [
+                process.env.EDITOR
+            ];
+            return [
+                null
+            ];
+        }
+        module.exports = guessEditor;
+        module.exports.getEditorFromMacProcesses = getEditorFromMacProcesses;
+        module.exports.getEditorFromWindowsProcesses = getEditorFromWindowsProcesses;
+        module.exports.getEditorFromLinuxProcesses = getEditorFromLinuxProcesses;
+    },
+    "./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fs = __webpack_require__("fs");
+        const os = __webpack_require__("os");
+        const path = __webpack_require__("path");
+        const colors = __webpack_require__("./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        const childProcess = __webpack_require__("child_process");
+        const guessEditor = __webpack_require__("./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/guess.js");
+        const getArgumentsForPosition = __webpack_require__("./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/get-args.js");
+        function wrapErrorCallback(cb) {
+            return (fileName, errorMessage)=>{
+                console.log();
+                console.log(colors.red('Could not open ' + path.basename(fileName) + ' in the editor.'));
+                if (errorMessage) {
+                    if ('.' !== errorMessage[errorMessage.length - 1]) errorMessage += '.';
+                    console.log(colors.red('The editor process exited with an error: ' + errorMessage));
+                }
+                console.log();
+                if (cb) cb(fileName, errorMessage);
+            };
+        }
+        function isTerminalEditor(editor) {
+            switch(editor){
+                case 'vim':
+                case 'emacs':
+                case 'nano':
+                    return true;
+            }
+            return false;
+        }
+        const positionRE = /:(\d+)(:(\d+))?$/;
+        function parseFile(file) {
+            if (file.startsWith('file://')) file = __webpack_require__("url?b918").fileURLToPath(file);
+            const fileName = file.replace(positionRE, '');
+            const match = file.match(positionRE);
+            const lineNumber = match && match[1];
+            const columnNumber = match && match[3];
+            return {
+                fileName,
+                lineNumber,
+                columnNumber
+            };
+        }
+        let currentChildProcess = null;
+        function launchEditor(file, specifiedEditor, onErrorCallback) {
+            const parsed = parseFile(file);
+            let { fileName } = parsed;
+            const { lineNumber, columnNumber } = parsed;
+            if ('win32' === process.platform && path.resolve(fileName).startsWith('\\\\')) return onErrorCallback(fileName, "UNC paths are not supported on Windows to avoid security issues. See https://github.com/vitejs/launch-editor/tree/main/packages/launch-editor#unc-paths-on-windows for details.");
+            if (!fs.existsSync(fileName)) return;
+            if ('function' == typeof specifiedEditor) {
+                onErrorCallback = specifiedEditor;
+                specifiedEditor = void 0;
+            }
+            onErrorCallback = wrapErrorCallback(onErrorCallback);
+            const [editor, ...args] = guessEditor(specifiedEditor);
+            if (!editor) return void onErrorCallback(fileName, null);
+            if ('linux' === process.platform && fileName.startsWith('/mnt/') && /Microsoft/i.test(os.release())) fileName = path.relative('', fileName);
+            if (lineNumber) {
+                const extraArgs = getArgumentsForPosition(editor, fileName, lineNumber, columnNumber);
+                args.push.apply(args, extraArgs);
+            } else args.push(fileName);
+            if (currentChildProcess && isTerminalEditor(editor)) currentChildProcess.kill('SIGKILL');
+            if ('win32' === process.platform) {
+                function escapeCmdArgs(cmdArgs) {
+                    return cmdArgs.replace(/([&|<>,;=^])/g, '^$1');
+                }
+                function doubleQuoteIfNeeded(str) {
+                    if (str.includes('^')) return `^"${str}^"`;
+                    if (str.includes(' ')) return `"${str}"`;
+                    return str;
+                }
+                const launchCommand = [
+                    editor,
+                    ...args.map(escapeCmdArgs)
+                ].map(doubleQuoteIfNeeded).join(' ');
+                currentChildProcess = childProcess.exec(launchCommand, {
+                    stdio: 'inherit',
+                    shell: true
+                });
+            } else currentChildProcess = childProcess.spawn(editor, args, {
+                stdio: 'inherit'
+            });
+            currentChildProcess.on('exit', function(errorCode) {
+                currentChildProcess = null;
+                if (errorCode) onErrorCallback(fileName, '(code ' + errorCode + ')');
+            });
+            currentChildProcess.on('error', function(error) {
+                let { code, message } = error;
+                if ('ENOENT' === code) message = `${message} ('${editor}' command does not exist in 'PATH')`;
+                onErrorCallback(fileName, message);
+            });
+        }
+        module.exports = launchEditor;
+    },
+    "./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
+        let p = process || {}, argv = p.argv || [], env = p.env || {};
+        let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
+        let formatter = (open, close, replace = open)=>(input)=>{
+                let string = "" + input, index = string.indexOf(close, open.length);
+                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+            };
+        let replaceClose = (string, close, replace, index)=>{
+            let result = "", cursor = 0;
+            do {
+                result += string.substring(cursor, index) + replace;
+                cursor = index + close.length;
+                index = string.indexOf(close, cursor);
+            }while (~index);
+            return result + string.substring(cursor);
+        };
+        let createColors = (enabled = isColorSupported)=>{
+            let f = enabled ? formatter : ()=>String;
+            return {
+                isColorSupported: enabled,
+                reset: f("\x1b[0m", "\x1b[0m"),
+                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+                italic: f("\x1b[3m", "\x1b[23m"),
+                underline: f("\x1b[4m", "\x1b[24m"),
+                inverse: f("\x1b[7m", "\x1b[27m"),
+                hidden: f("\x1b[8m", "\x1b[28m"),
+                strikethrough: f("\x1b[9m", "\x1b[29m"),
+                black: f("\x1b[30m", "\x1b[39m"),
+                red: f("\x1b[31m", "\x1b[39m"),
+                green: f("\x1b[32m", "\x1b[39m"),
+                yellow: f("\x1b[33m", "\x1b[39m"),
+                blue: f("\x1b[34m", "\x1b[39m"),
+                magenta: f("\x1b[35m", "\x1b[39m"),
+                cyan: f("\x1b[36m", "\x1b[39m"),
+                white: f("\x1b[37m", "\x1b[39m"),
+                gray: f("\x1b[90m", "\x1b[39m"),
+                bgBlack: f("\x1b[40m", "\x1b[49m"),
+                bgRed: f("\x1b[41m", "\x1b[49m"),
+                bgGreen: f("\x1b[42m", "\x1b[49m"),
+                bgYellow: f("\x1b[43m", "\x1b[49m"),
+                bgBlue: f("\x1b[44m", "\x1b[49m"),
+                bgMagenta: f("\x1b[45m", "\x1b[49m"),
+                bgCyan: f("\x1b[46m", "\x1b[49m"),
+                bgWhite: f("\x1b[47m", "\x1b[49m"),
+                blackBright: f("\x1b[90m", "\x1b[39m"),
+                redBright: f("\x1b[91m", "\x1b[39m"),
+                greenBright: f("\x1b[92m", "\x1b[39m"),
+                yellowBright: f("\x1b[93m", "\x1b[39m"),
+                blueBright: f("\x1b[94m", "\x1b[39m"),
+                magentaBright: f("\x1b[95m", "\x1b[39m"),
+                cyanBright: f("\x1b[96m", "\x1b[39m"),
+                whiteBright: f("\x1b[97m", "\x1b[39m"),
+                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+                bgRedBright: f("\x1b[101m", "\x1b[49m"),
+                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
+            };
+        };
+        module.exports = createColors();
+        module.exports.createColors = createColors;
+    },
+    "./node_modules/.pnpm/shell-quote@1.8.4/node_modules/shell-quote/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        __webpack_require__("./node_modules/.pnpm/shell-quote@1.8.4/node_modules/shell-quote/quote.js");
+        exports.parse = __webpack_require__("./node_modules/.pnpm/shell-quote@1.8.4/node_modules/shell-quote/parse.js");
+    },
+    "./node_modules/.pnpm/shell-quote@1.8.4/node_modules/shell-quote/parse.js" (module) {
+        var CONTROL = "(?:\\|\\||\\&\\&|;;|\\|\\&|\\<\\(|\\<\\<\\<|>>|>\\&|<\\&|[&;()|<>])";
+        var controlRE = new RegExp('^' + CONTROL + '$');
+        var META = '|&;()<> \\t';
+        var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+        var DOUBLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
+        var hash = /^#$/;
+        var SQ = "'";
+        var DQ = '"';
+        var DS = '$';
+        var TOKEN = '';
+        var mult = 0x100000000;
+        for(var i = 0; i < 4; i++)TOKEN += (mult * Math.random()).toString(16);
+        var startsWithToken = new RegExp('^' + TOKEN);
+        function matchAll(s, r) {
+            var origIndex = r.lastIndex;
+            var matches = [];
+            var matchObj;
+            while(matchObj = r.exec(s)){
+                matches.push(matchObj);
+                if (r.lastIndex === matchObj.index) r.lastIndex += 1;
+            }
+            r.lastIndex = origIndex;
+            return matches;
+        }
+        function getVar(env, pre, key) {
+            var r = 'function' == typeof env ? env(key) : env[key];
+            if (void 0 === r && '' != key) r = '';
+            else if (void 0 === r) r = '$';
+            if ('object' == typeof r) return pre + TOKEN + JSON.stringify(r) + TOKEN;
+            return pre + r;
+        }
+        function parseInternal(string, env, opts) {
+            if (!opts) opts = {};
+            var BS = opts.escape || '\\';
+            var BAREWORD = '(\\' + BS + '[\'"' + META + ']|[^\\s\'"' + META + '])+';
+            var chunker = new RegExp([
+                '(' + CONTROL + ')',
+                '(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')+'
+            ].join('|'), 'g');
+            var matches = matchAll(string, chunker);
+            if (0 === matches.length) return [];
+            if (!env) env = {};
+            var commented = false;
+            return matches.map(function(match) {
+                var s = match[0];
+                if (!s || commented) return;
+                if (controlRE.test(s)) return {
+                    op: s
+                };
+                var quote = false;
+                var esc = false;
+                var out = '';
+                var isGlob = false;
+                var i;
+                function parseEnvVar() {
+                    i += 1;
+                    var varend;
+                    var varname;
+                    var char = s.charAt(i);
+                    if ('{' === char) {
+                        i += 1;
+                        if ('}' === s.charAt(i)) throw new Error('Bad substitution: ' + s.slice(i - 2, i + 1));
+                        varend = s.indexOf('}', i);
+                        if (varend < 0) throw new 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_]/);
+                        if (varend) {
+                            varname = slicedFromI.slice(0, varend.index);
+                            i += varend.index - 1;
+                        } else {
+                            varname = slicedFromI;
+                            i = s.length;
+                        }
+                    }
+                    return getVar(env, '', varname);
+                }
+                for(i = 0; i < s.length; i++){
+                    var c = s.charAt(i);
+                    isGlob = isGlob || !quote && ('*' === c || '?' === c);
+                    if (esc) {
+                        out += c;
+                        esc = false;
+                    } else if (quote) if (c === quote) quote = false;
+                    else if (quote == SQ) out += c;
+                    else if (c === BS) {
+                        i += 1;
+                        c = s.charAt(i);
+                        if (c === DQ || c === BS || c === DS) out += c;
+                        else out += BS + c;
+                    } else if (c === DS) out += parseEnvVar();
+                    else out += c;
+                    else if (c === DQ || c === SQ) quote = c;
+                    else if (controlRE.test(c)) return {
+                        op: s
+                    };
+                    else if (hash.test(c)) {
+                        commented = true;
+                        var commentObj = {
+                            comment: string.slice(match.index + i + 1)
+                        };
+                        if (out.length) return [
+                            out,
+                            commentObj
+                        ];
+                        return [
+                            commentObj
+                        ];
+                    } else if (c === BS) esc = true;
+                    else if (c === DS) out += parseEnvVar();
+                    else out += c;
+                }
+                if (isGlob) return {
+                    op: 'glob',
+                    pattern: out
+                };
+                return out;
+            }).reduce(function(prev, arg) {
+                return void 0 === arg ? prev : prev.concat(arg);
+            }, []);
+        }
+        module.exports = function(s, env, opts) {
+            var mapped = parseInternal(s, env, opts);
+            if ('function' != typeof env) return mapped;
+            return mapped.reduce(function(acc, s) {
+                if ('object' == typeof s) return acc.concat(s);
+                var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
+                if (1 === xs.length) return acc.concat(xs[0]);
+                return acc.concat(xs.filter(Boolean).map(function(x) {
+                    if (startsWithToken.test(x)) return JSON.parse(x.split(TOKEN)[1]);
+                    return x;
+                }));
+            }, []);
+        };
+    },
+    "./node_modules/.pnpm/shell-quote@1.8.4/node_modules/shell-quote/quote.js" (module) {
+        var OPS = [
+            '||',
+            '&&',
+            ';;',
+            '|&',
+            '<(',
+            '<<<',
+            '>>',
+            '>&',
+            '<&',
+            '&',
+            ';',
+            '(',
+            ')',
+            '|',
+            '<',
+            '>'
+        ];
+        var LINE_TERMINATORS = /[\n\r\u2028\u2029]/;
+        var GLOB_SHELL_SPECIAL = /[\s#!"$&'():;<=>@\\^`|]/g;
+        module.exports = function(xs) {
+            return xs.map(function(s) {
+                if ('' === s) return '\'\'';
+                if (s && 'object' == typeof s) {
+                    if ('glob' === s.op) {
+                        if ('string' != typeof s.pattern) throw new TypeError('glob token requires a string `pattern`');
+                        if (LINE_TERMINATORS.test(s.pattern)) throw new TypeError('glob `pattern` must not contain line terminators');
+                        return s.pattern.replace(GLOB_SHELL_SPECIAL, '\\$&');
+                    }
+                    if ('string' == typeof s.op) {
+                        if (OPS.indexOf(s.op) < 0) throw new TypeError('invalid `op` value: ' + JSON.stringify(s.op));
+                        return s.op.replace(/[\s\S]/g, '\\$&');
+                    }
+                    if ('string' == typeof s.comment) {
+                        if (LINE_TERMINATORS.test(s.comment)) throw new TypeError('`comment` must not contain line terminators');
+                        return '#' + s.comment;
+                    }
+                    throw new TypeError('unrecognized object token shape');
+                }
+                if (/["\s\\]/.test(s) && !/'/.test(s)) return "'" + s.replace(/(['])/g, '\\$1') + "'";
+                if (/["'\s]/.test(s)) return '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"';
+                return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, '$1\\$2');
+            }).join(' ');
+        };
+    }
+});
+__webpack_require__("./node_modules/.pnpm/launch-editor@2.14.1/node_modules/launch-editor/index.js");