import { __webpack_require__ } from "./465.js";
import "./465.js";
__webpack_require__.add({
    "./node_modules/.pnpm/launch-editor@2.13.2/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.2/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.13.2/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.2/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.13.2/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.3/node_modules/shell-quote/index.js");
        const childProcess = __webpack_require__("child_process");
        const COMMON_EDITORS_MACOS = __webpack_require__("./node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/editor-info/macos.js");
        const COMMON_EDITORS_LINUX = __webpack_require__("./node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/editor-info/linux.js");
        const COMMON_EDITORS_WIN = __webpack_require__("./node_modules/.pnpm/launch-editor@2.13.2/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) {
                    const output = childProcess.execSync('ps x -o comm=', {
                        stdio: [
                            'pipe',
                            'pipe',
                            'ignore'
                        ]
                    }).toString();
                    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
                            ];
                        }
                    }
                } 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 runningProcesses = output.split('\r\n');
                    for(let i = 0; i < runningProcesses.length; i++){
                        const fullProcessPath = runningProcesses[i].trim();
                        const shortProcessName = path.basename(fullProcessPath);
                        if (-1 !== COMMON_EDITORS_WIN.indexOf(shortProcessName)) return [
                            fullProcessPath
                        ];
                    }
                } else if ('linux' === process.platform) {
                    const output = childProcess.execSync('ps x --no-heading -o comm --sort=comm', {
                        stdio: [
                            'pipe',
                            'pipe',
                            'ignore'
                        ]
                    }).toString();
                    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]
                        ];
                    }
                }
            } catch (ignoreError) {}
            if (process.env.VISUAL) return [
                process.env.VISUAL
            ];
            if (process.env.EDITOR) return [
                process.env.EDITOR
            ];
            return [
                null
            ];
        };
    },
    "./node_modules/.pnpm/launch-editor@2.13.2/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.13.2/node_modules/launch-editor/guess.js");
        const getArgumentsForPosition = __webpack_require__("./node_modules/.pnpm/launch-editor@2.13.2/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 _childProcess = null;
        function launchEditor(file, specifiedEditor, onErrorCallback) {
            const parsed = parseFile(file);
            let { fileName } = parsed;
            const { lineNumber, columnNumber } = parsed;
            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 (_childProcess && isTerminalEditor(editor)) _childProcess.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(' ');
                _childProcess = childProcess.exec(launchCommand, {
                    stdio: 'inherit',
                    shell: true
                });
            } else _childProcess = childProcess.spawn(editor, args, {
                stdio: 'inherit'
            });
            _childProcess.on('exit', function(errorCode) {
                _childProcess = null;
                if (errorCode) onErrorCallback(fileName, '(code ' + errorCode + ')');
            });
            _childProcess.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.3/node_modules/shell-quote/index.js" (__unused_rspack_module, exports, __webpack_require__) {
        __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) {
        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.3/node_modules/shell-quote/quote.js" (module) {
        module.exports = function(xs) {
            return xs.map(function(s) {
                if ('' === s) return '\'\'';
                if (s && 'object' == typeof s) return s.op.replace(/(.)/g, '\\$1');
                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.13.2/node_modules/launch-editor/index.js");
