upgrade-rspeedy-canary
Version:
Upgrade Rspeedy-related packages
2,370 lines • 119 kB
JavaScript
#!/usr/bin/env node
import external_process_default from "process";
import external_os_default from "os";
import external_tty_default from "tty";
import { EOL } from "node:os";
import { createRequire } from "node:module";
import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:child_process";
import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
import * as __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__ from "node:process";
var __webpack_modules__ = {
"../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js": function(module) {
let p = process || {}, argv = p.argv || [], env = p.env || {};
let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
let formatter = (open, close, replace = open)=>(input)=>{
let string = "" + input, index = string.indexOf(close, open.length);
return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
};
let replaceClose = (string, close, replace, index)=>{
let result = "", cursor = 0;
do {
result += string.substring(cursor, index) + replace;
cursor = index + close.length;
index = string.indexOf(close, cursor);
}while (~index);
return result + string.substring(cursor);
};
let createColors = (enabled = isColorSupported)=>{
let f = enabled ? formatter : ()=>String;
return {
isColorSupported: enabled,
reset: f("\x1b[0m", "\x1b[0m"),
bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
italic: f("\x1b[3m", "\x1b[23m"),
underline: f("\x1b[4m", "\x1b[24m"),
inverse: f("\x1b[7m", "\x1b[27m"),
hidden: f("\x1b[8m", "\x1b[28m"),
strikethrough: f("\x1b[9m", "\x1b[29m"),
black: f("\x1b[30m", "\x1b[39m"),
red: f("\x1b[31m", "\x1b[39m"),
green: f("\x1b[32m", "\x1b[39m"),
yellow: f("\x1b[33m", "\x1b[39m"),
blue: f("\x1b[34m", "\x1b[39m"),
magenta: f("\x1b[35m", "\x1b[39m"),
cyan: f("\x1b[36m", "\x1b[39m"),
white: f("\x1b[37m", "\x1b[39m"),
gray: f("\x1b[90m", "\x1b[39m"),
bgBlack: f("\x1b[40m", "\x1b[49m"),
bgRed: f("\x1b[41m", "\x1b[49m"),
bgGreen: f("\x1b[42m", "\x1b[49m"),
bgYellow: f("\x1b[43m", "\x1b[49m"),
bgBlue: f("\x1b[44m", "\x1b[49m"),
bgMagenta: f("\x1b[45m", "\x1b[49m"),
bgCyan: f("\x1b[46m", "\x1b[49m"),
bgWhite: f("\x1b[47m", "\x1b[49m"),
blackBright: f("\x1b[90m", "\x1b[39m"),
redBright: f("\x1b[91m", "\x1b[39m"),
greenBright: f("\x1b[92m", "\x1b[39m"),
yellowBright: f("\x1b[93m", "\x1b[39m"),
blueBright: f("\x1b[94m", "\x1b[39m"),
magentaBright: f("\x1b[95m", "\x1b[39m"),
cyanBright: f("\x1b[96m", "\x1b[39m"),
whiteBright: f("\x1b[97m", "\x1b[39m"),
bgBlackBright: f("\x1b[100m", "\x1b[49m"),
bgRedBright: f("\x1b[101m", "\x1b[49m"),
bgGreenBright: f("\x1b[102m", "\x1b[49m"),
bgYellowBright: f("\x1b[103m", "\x1b[49m"),
bgBlueBright: f("\x1b[104m", "\x1b[49m"),
bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
bgCyanBright: f("\x1b[106m", "\x1b[49m"),
bgWhiteBright: f("\x1b[107m", "\x1b[49m")
};
};
module.exports = createColors();
module.exports.createColors = createColors;
},
"./src/main.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.d(__webpack_exports__, {
D: ()=>main
});
var commander = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/index.js");
const { program: esm_program, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help } = commander;
function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : external_process_default.argv) {
const prefix = flag.startsWith("-") ? "" : 1 === flag.length ? "-" : "--";
const position = argv.indexOf(prefix + flag);
const terminatorPosition = argv.indexOf("--");
return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
}
var { env } = external_process_default;
var flagForceColor;
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
function envForceColor() {
if ("FORCE_COLOR" in env) {
if ("true" === env.FORCE_COLOR) return 1;
if ("false" === env.FORCE_COLOR) return 0;
return 0 === env.FORCE_COLOR.length ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
}
}
function translateLevel(level) {
if (0 === level) return false;
return {
level,
hasBasic: true,
has256: level >= 2,
has16m: level >= 3
};
}
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
const noFlagForceColor = envForceColor();
if (void 0 !== noFlagForceColor) flagForceColor = noFlagForceColor;
const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
if (0 === forceColor) return 0;
if (sniffFlags) {
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
if (hasFlag("color=256")) return 2;
}
if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
const min = forceColor || 0;
if ("dumb" === env.TERM) return min;
if ("win32" === external_process_default.platform) {
const osRelease = external_os_default.release().split(".");
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
return 1;
}
if ("CI" in env) {
if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) return 3;
if ([
"TRAVIS",
"CIRCLECI",
"APPVEYOR",
"GITLAB_CI",
"BUILDKITE",
"DRONE"
].some((sign)=>sign in env) || "codeship" === env.CI_NAME) return 1;
return min;
}
if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
if ("truecolor" === env.COLORTERM) return 3;
if ("xterm-kitty" === env.TERM) return 3;
if ("TERM_PROGRAM" in env) {
const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
switch(env.TERM_PROGRAM){
case "iTerm.app":
return version >= 3 ? 3 : 2;
case "Apple_Terminal":
return 2;
}
}
if (/-256(color)?$/i.test(env.TERM)) return 2;
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
if ("COLORTERM" in env) return 1;
return min;
}
function createSupportsColor(stream, options = {}) {
const level = _supportsColor(stream, {
streamIsTTY: stream && stream.isTTY,
...options
});
return translateLevel(level);
}
var supportsColor = {
stdout: createSupportsColor({
isTTY: external_tty_default.isatty(1)
}),
stderr: createSupportsColor({
isTTY: external_tty_default.isatty(2)
})
};
var supports_color_default = supportsColor;
var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
var anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
var isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
var formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
let string = "" + input;
let index = string.indexOf(close, open.length);
return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
} : String;
var replaceClose = (string, close, replace, index)=>{
let start = string.substring(0, index) + replace;
let end = string.substring(index + close.length);
let nextIndex = end.indexOf(close);
return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
};
var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
var red = formatter("\x1B[31m", "\x1B[39m");
var green = formatter("\x1B[32m", "\x1B[39m");
var yellow = formatter("\x1B[33m", "\x1B[39m");
var magenta = formatter("\x1B[35m", "\x1B[39m");
var cyan = formatter("\x1B[36m", "\x1B[39m");
var gray = formatter("\x1B[90m", "\x1B[39m");
var startColor = [
189,
255,
243
];
var endColor = [
74,
194,
154
];
var isWord = (char)=>!/[\s\n]/.test(char);
var gradient = (message)=>{
if (colorLevel < 3) return 2 === colorLevel ? bold(cyan(message)) : message;
let chars = [
...message
];
let steps = chars.filter(isWord).length;
let r = startColor[0];
let g = startColor[1];
let b = startColor[2];
let rStep = (endColor[0] - r) / steps;
let gStep = (endColor[1] - g) / steps;
let bStep = (endColor[2] - b) / steps;
let output = "";
for (let char of chars){
if (isWord(char)) {
r += rStep;
g += gStep;
b += bStep;
}
output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1B[39m`;
}
return bold(output);
};
var LOG_LEVEL = {
error: 0,
warn: 1,
info: 2,
log: 3,
verbose: 4
};
var LOG_TYPES = {
error: {
label: "error",
level: "error",
color: red
},
warn: {
label: "warn",
level: "warn",
color: yellow
},
info: {
label: "info",
level: "info",
color: cyan
},
start: {
label: "start",
level: "info",
color: cyan
},
ready: {
label: "ready",
level: "info",
color: green
},
success: {
label: "success",
level: "info",
color: green
},
log: {
level: "log"
},
debug: {
label: "debug",
level: "verbose",
color: magenta
}
};
var createLogger = (options = {})=>{
let maxLevel = options.level || "log";
let log = (type, message, ...args)=>{
if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) return;
if (null == message) return console.log();
let logType = LOG_TYPES[type];
let label = "";
let text = "";
if ("label" in logType) {
label = (logType.label || "").padEnd(7);
label = bold(logType.color ? logType.color(label) : label);
}
if (message instanceof Error) if (message.stack) {
let [name, ...rest] = message.stack.split("\n");
if (name.startsWith("Error: ")) name = name.slice(7);
text = `${name}
${gray(rest.join("\n"))}`;
} else text = message.message;
else if ("error" === logType.level && "string" == typeof message) {
let lines = message.split("\n");
text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join("\n");
} else text = `${message}`;
console.log(label.length ? `${label} ${text}` : text, ...args);
};
let logger2 = {
greet: (message)=>log("log", gradient(message))
};
Object.keys(LOG_TYPES).forEach((key)=>{
logger2[key] = (...args)=>log(key, ...args);
});
Object.defineProperty(logger2, "level", {
get: ()=>maxLevel,
set (val) {
maxLevel = val;
}
});
logger2.override = (customLogger)=>{
Object.assign(logger2, customLogger);
};
return logger2;
};
var logger = createLogger();
var external_node_fs_ = __webpack_require__("node:fs");
var external_node_path_ = __webpack_require__("node:path");
const INDENT_REGEX = /^(?:( )+|\t+)/;
const INDENT_TYPE_SPACE = 'space';
const INDENT_TYPE_TAB = 'tab';
function makeIndentsMap(string, ignoreSingleSpaces) {
const indents = new Map();
let previousSize = 0;
let previousIndentType;
let key;
for (const line of string.split(/\n/g)){
if (!line) continue;
let indent;
let indentType;
let use;
let weight;
let entry;
const matches = line.match(INDENT_REGEX);
if (null === matches) {
previousSize = 0;
previousIndentType = '';
} else {
indent = matches[0].length;
indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && 1 === indent) continue;
if (indentType !== previousIndentType) previousSize = 0;
previousIndentType = indentType;
use = 1;
weight = 0;
const indentDifference = indent - previousSize;
previousSize = indent;
if (0 === indentDifference) {
use = 0;
weight = 1;
} else {
const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
key = encodeIndentsKey(indentType, absoluteIndentDifference);
}
entry = indents.get(key);
entry = void 0 === entry ? [
1,
0
] : [
entry[0] + use,
entry[1] + weight
];
indents.set(key, entry);
}
}
return indents;
}
function encodeIndentsKey(indentType, indentAmount) {
const typeCharacter = indentType === INDENT_TYPE_SPACE ? 's' : 't';
return typeCharacter + String(indentAmount);
}
function decodeIndentsKey(indentsKey) {
const keyHasTypeSpace = 's' === indentsKey[0];
const type = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
const amount = Number(indentsKey.slice(1));
return {
type,
amount
};
}
function getMostUsedKey(indents) {
let result;
let maxUsed = 0;
let maxWeight = 0;
for (const [key, [usedCount, weight]] of indents)if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
maxUsed = usedCount;
maxWeight = weight;
result = key;
}
return result;
}
function makeIndentString(type, amount) {
const indentCharacter = type === INDENT_TYPE_SPACE ? ' ' : '\t';
return indentCharacter.repeat(amount);
}
function detectIndent(string) {
if ('string' != typeof string) throw new TypeError('Expected a string');
let indents = makeIndentsMap(string, true);
if (0 === indents.size) indents = makeIndentsMap(string, false);
const keyOfMostUsedIndent = getMostUsedKey(indents);
let type;
let amount = 0;
let indent = '';
if (void 0 !== keyOfMostUsedIndent) {
({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
indent = makeIndentString(type, amount);
}
return {
amount,
type,
indent
};
}
var picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
const version_require = createRequire(import.meta.url);
const version_pkg = version_require('../package.json');
const version_version = version_pkg.version;
const devDependencies = version_pkg.devDependencies;
const LYNX_RSPEEDY = '@lynx-js/rspeedy';
async function install(cwd) {
const packageJSONPath = external_node_path_["default"].resolve(cwd, 'package.json');
if (!external_node_fs_["default"].existsSync(packageJSONPath)) {
const message = `${picocolors_default().underline(picocolors_default().yellow(packageJSONPath))} not found. Please run ${picocolors_default().bold('upgrade-rspeedy')} in your Rspeedy project.`;
logger.error(message);
throw new Error(message);
}
try {
const content = await external_node_fs_["default"].promises.readFile(packageJSONPath, 'utf-8');
const pkg = JSON.parse(content);
if (pkg.dependencies?.[LYNX_RSPEEDY] === void 0 && pkg.devDependencies?.[LYNX_RSPEEDY] === void 0) throw new Error(`No ${picocolors_default().yellow(LYNX_RSPEEDY)} found in ${packageJSONPath}.
Please run ${picocolors_default().bold('upgrade-rspeedy')} in your Rspeedy project.`);
const { indent } = detectIndent(content);
console.info();
const dependenciesUpdated = updateDependencies(pkg, packageJSONPath, 'dependencies');
console.info();
const devDependenciesUpdated = updateDependencies(pkg, packageJSONPath, 'devDependencies');
console.info();
if (dependenciesUpdated || devDependenciesUpdated) {
await external_node_fs_["default"].promises.writeFile(packageJSONPath, JSON.stringify(pkg, null, indent) + EOL, 'utf-8');
logger.success(`${picocolors_default().yellow(packageJSONPath)} has been updated.`);
logger.success("Please install the dependencies with your package manager.");
}
} catch (error) {
logger.error(error);
throw error;
}
}
function updateDependencies(pkg, packageJSONPath, name) {
const dependencies = pkg[name];
if (!dependencies) {
logger.info(`No ${picocolors_default().yellow(name)} is found in ${picocolors_default().underline(packageJSONPath)}`);
return false;
}
const updatedDependencies = findDependencies(dependencies).filter(([, { original, target }])=>original !== target);
if (0 === updatedDependencies.length) {
logger.info(`No ${picocolors_default().yellow(name)} need to be updated in ${picocolors_default().underline(packageJSONPath)}`);
return false;
}
{
const sep = '\n - ';
logger.info(`Updated ${picocolors_default().yellow(name)}:\n${sep}${updatedDependencies.map(([name, { original, target }])=>`${picocolors_default().cyan(name)}: ${picocolors_default().dim(original)} -> ${picocolors_default().green(target)}`).join(sep)}`);
}
updatedDependencies.forEach(([dependency, { target }])=>{
dependencies[dependency] = target;
});
return true;
}
const targetDependencies = new Map(Object.entries(devDependencies ?? {}));
function findDependencies(dependencies) {
return Object.entries(dependencies).map(([name, original])=>{
if (targetDependencies.has(name) && (name.startsWith('@lynx-js/') || name.includes('rsbuild'))) return [
name,
{
original,
target: targetDependencies.get(name)
}
];
return null;
}).filter((i)=>null !== i);
}
async function main(cwd, argv) {
const program = new Command('upgrade-rspeedy');
const { npm_execpath } = process.env;
if (!npm_execpath || npm_execpath.includes('npm-cli.js') || npm_execpath.includes('npx-cli.js')) console.info();
logger.greet(`Upgrade Rspeedy v${version_version}\n`);
program.helpCommand(false).description('Upgrade the Rspeedy-related packages').action(()=>install(cwd ?? process.cwd()));
await program.parseAsync(argv);
}
},
"./src/upgrade-rspeedy.ts": function(module, __webpack_exports__, __webpack_require__) {
__webpack_require__.a(module, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
try {
__webpack_require__.r(__webpack_exports__);
var _main_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/main.ts");
await (0, _main_js__WEBPACK_IMPORTED_MODULE_0__.D)();
__webpack_async_result__();
} catch (e) {
__webpack_async_result__(e);
}
}, 1);
},
"node:child_process": function(module) {
module.exports = __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__;
},
"node:events": function(module) {
module.exports = __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__;
},
"node:fs": function(module) {
module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__;
},
"node:path": function(module) {
module.exports = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__;
},
"node:process": function(module) {
module.exports = __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
const { Argument } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js");
const { Command } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/command.js");
const { CommanderError, InvalidArgumentError } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js");
const { Help } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/help.js");
const { Option } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/option.js");
exports.program = new Command();
exports.createCommand = (name)=>new Command(name);
exports.createOption = (flags, description)=>new Option(flags, description);
exports.createArgument = (name, description)=>new Argument(name, description);
exports.Command = Command;
exports.Option = Option;
exports.Argument = Argument;
exports.Help = Help;
exports.CommanderError = CommanderError;
exports.InvalidArgumentError = InvalidArgumentError;
exports.InvalidOptionArgumentError = InvalidArgumentError;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js": function(__unused_webpack_module, exports, __webpack_require__) {
const { InvalidArgumentError } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js");
class Argument {
constructor(name, description){
this.description = description || '';
this.variadic = false;
this.parseArg = void 0;
this.defaultValue = void 0;
this.defaultValueDescription = void 0;
this.argChoices = void 0;
switch(name[0]){
case '<':
this.required = true;
this._name = name.slice(1, -1);
break;
case '[':
this.required = false;
this._name = name.slice(1, -1);
break;
default:
this.required = true;
this._name = name;
break;
}
if (this._name.length > 3 && '...' === this._name.slice(-3)) {
this.variadic = true;
this._name = this._name.slice(0, -3);
}
}
name() {
return this._name;
}
_concatValue(value, previous) {
if (previous === this.defaultValue || !Array.isArray(previous)) return [
value
];
return previous.concat(value);
}
default(value, description) {
this.defaultValue = value;
this.defaultValueDescription = description;
return this;
}
argParser(fn) {
this.parseArg = fn;
return this;
}
choices(values) {
this.argChoices = values.slice();
this.parseArg = (arg, previous)=>{
if (!this.argChoices.includes(arg)) throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(', ')}.`);
if (this.variadic) return this._concatValue(arg, previous);
return arg;
};
return this;
}
argRequired() {
this.required = true;
return this;
}
argOptional() {
this.required = false;
return this;
}
}
function humanReadableArgName(arg) {
const nameOutput = arg.name() + (true === arg.variadic ? '...' : '');
return arg.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';
}
exports.Argument = Argument;
exports.humanReadableArgName = humanReadableArgName;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/command.js": function(__unused_webpack_module, exports, __webpack_require__) {
const EventEmitter = __webpack_require__("node:events").EventEmitter;
const childProcess = __webpack_require__("node:child_process");
const path = __webpack_require__("node:path");
const fs = __webpack_require__("node:fs");
const process1 = __webpack_require__("node:process");
const { Argument, humanReadableArgName } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js");
const { CommanderError } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js");
const { Help, stripColor } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/help.js");
const { Option, DualOptions } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/option.js");
const { suggestSimilar } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js");
class Command extends EventEmitter {
constructor(name){
super();
this.commands = [];
this.options = [];
this.parent = null;
this._allowUnknownOption = false;
this._allowExcessArguments = false;
this.registeredArguments = [];
this._args = this.registeredArguments;
this.args = [];
this.rawArgs = [];
this.processedArgs = [];
this._scriptPath = null;
this._name = name || '';
this._optionValues = {};
this._optionValueSources = {};
this._storeOptionsAsProperties = false;
this._actionHandler = null;
this._executableHandler = false;
this._executableFile = null;
this._executableDir = null;
this._defaultCommandName = null;
this._exitCallback = null;
this._aliases = [];
this._combineFlagAndOptionalValue = true;
this._description = '';
this._summary = '';
this._argsDescription = void 0;
this._enablePositionalOptions = false;
this._passThroughOptions = false;
this._lifeCycleHooks = {};
this._showHelpAfterError = false;
this._showSuggestionAfterError = true;
this._savedState = null;
this._outputConfiguration = {
writeOut: (str)=>process1.stdout.write(str),
writeErr: (str)=>process1.stderr.write(str),
outputError: (str, write)=>write(str),
getOutHelpWidth: ()=>process1.stdout.isTTY ? process1.stdout.columns : void 0,
getErrHelpWidth: ()=>process1.stderr.isTTY ? process1.stderr.columns : void 0,
getOutHasColors: ()=>useColor() ?? (process1.stdout.isTTY && process1.stdout.hasColors?.()),
getErrHasColors: ()=>useColor() ?? (process1.stderr.isTTY && process1.stderr.hasColors?.()),
stripColor: (str)=>stripColor(str)
};
this._hidden = false;
this._helpOption = void 0;
this._addImplicitHelpCommand = void 0;
this._helpCommand = void 0;
this._helpConfiguration = {};
}
copyInheritedSettings(sourceCommand) {
this._outputConfiguration = sourceCommand._outputConfiguration;
this._helpOption = sourceCommand._helpOption;
this._helpCommand = sourceCommand._helpCommand;
this._helpConfiguration = sourceCommand._helpConfiguration;
this._exitCallback = sourceCommand._exitCallback;
this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
this._allowExcessArguments = sourceCommand._allowExcessArguments;
this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
this._showHelpAfterError = sourceCommand._showHelpAfterError;
this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
return this;
}
_getCommandAndAncestors() {
const result = [];
for(let command = this; command; command = command.parent)result.push(command);
return result;
}
command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
let desc = actionOptsOrExecDesc;
let opts = execOpts;
if ('object' == typeof desc && null !== desc) {
opts = desc;
desc = null;
}
opts = opts || {};
const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
const cmd = this.createCommand(name);
if (desc) {
cmd.description(desc);
cmd._executableHandler = true;
}
if (opts.isDefault) this._defaultCommandName = cmd._name;
cmd._hidden = !!(opts.noHelp || opts.hidden);
cmd._executableFile = opts.executableFile || null;
if (args) cmd.arguments(args);
this._registerCommand(cmd);
cmd.parent = this;
cmd.copyInheritedSettings(this);
if (desc) return this;
return cmd;
}
createCommand(name) {
return new Command(name);
}
createHelp() {
return Object.assign(new Help(), this.configureHelp());
}
configureHelp(configuration) {
if (void 0 === configuration) return this._helpConfiguration;
this._helpConfiguration = configuration;
return this;
}
configureOutput(configuration) {
if (void 0 === configuration) return this._outputConfiguration;
Object.assign(this._outputConfiguration, configuration);
return this;
}
showHelpAfterError(displayHelp = true) {
if ('string' != typeof displayHelp) displayHelp = !!displayHelp;
this._showHelpAfterError = displayHelp;
return this;
}
showSuggestionAfterError(displaySuggestion = true) {
this._showSuggestionAfterError = !!displaySuggestion;
return this;
}
addCommand(cmd, opts) {
if (!cmd._name) throw new Error(`Command passed to .addCommand() must have a name
- specify the name in Command constructor or using .name()`);
opts = opts || {};
if (opts.isDefault) this._defaultCommandName = cmd._name;
if (opts.noHelp || opts.hidden) cmd._hidden = true;
this._registerCommand(cmd);
cmd.parent = this;
cmd._checkForBrokenPassThrough();
return this;
}
createArgument(name, description) {
return new Argument(name, description);
}
argument(name, description, fn, defaultValue) {
const argument = this.createArgument(name, description);
if ('function' == typeof fn) argument.default(defaultValue).argParser(fn);
else argument.default(fn);
this.addArgument(argument);
return this;
}
arguments(names) {
names.trim().split(/ +/).forEach((detail)=>{
this.argument(detail);
});
return this;
}
addArgument(argument) {
const previousArgument = this.registeredArguments.slice(-1)[0];
if (previousArgument && previousArgument.variadic) throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
if (argument.required && void 0 !== argument.defaultValue && void 0 === argument.parseArg) throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
this.registeredArguments.push(argument);
return this;
}
helpCommand(enableOrNameAndArgs, description) {
if ('boolean' == typeof enableOrNameAndArgs) {
this._addImplicitHelpCommand = enableOrNameAndArgs;
return this;
}
enableOrNameAndArgs = enableOrNameAndArgs ?? 'help [command]';
const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
const helpDescription = description ?? 'display help for command';
const helpCommand = this.createCommand(helpName);
helpCommand.helpOption(false);
if (helpArgs) helpCommand.arguments(helpArgs);
if (helpDescription) helpCommand.description(helpDescription);
this._addImplicitHelpCommand = true;
this._helpCommand = helpCommand;
return this;
}
addHelpCommand(helpCommand, deprecatedDescription) {
if ('object' != typeof helpCommand) {
this.helpCommand(helpCommand, deprecatedDescription);
return this;
}
this._addImplicitHelpCommand = true;
this._helpCommand = helpCommand;
return this;
}
_getHelpCommand() {
const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand('help'));
if (hasImplicitHelpCommand) {
if (void 0 === this._helpCommand) this.helpCommand(void 0, void 0);
return this._helpCommand;
}
return null;
}
hook(event, listener) {
const allowedValues = [
'preSubcommand',
'preAction',
'postAction'
];
if (!allowedValues.includes(event)) throw new Error(`Unexpected value for event passed to hook : '${event}'.
Expecting one of '${allowedValues.join("', '")}'`);
if (this._lifeCycleHooks[event]) this._lifeCycleHooks[event].push(listener);
else this._lifeCycleHooks[event] = [
listener
];
return this;
}
exitOverride(fn) {
if (fn) this._exitCallback = fn;
else this._exitCallback = (err)=>{
if ('commander.executeSubCommandAsync' !== err.code) throw err;
};
return this;
}
_exit(exitCode, code, message) {
if (this._exitCallback) this._exitCallback(new CommanderError(exitCode, code, message));
process1.exit(exitCode);
}
action(fn) {
const listener = (args)=>{
const expectedArgsCount = this.registeredArguments.length;
const actionArgs = args.slice(0, expectedArgsCount);
if (this._storeOptionsAsProperties) actionArgs[expectedArgsCount] = this;
else actionArgs[expectedArgsCount] = this.opts();
actionArgs.push(this);
return fn.apply(this, actionArgs);
};
this._actionHandler = listener;
return this;
}
createOption(flags, description) {
return new Option(flags, description);
}
_callParseArg(target, value, previous, invalidArgumentMessage) {
try {
return target.parseArg(value, previous);
} catch (err) {
if ('commander.invalidArgument' === err.code) {
const message = `${invalidArgumentMessage} ${err.message}`;
this.error(message, {
exitCode: err.exitCode,
code: err.code
});
}
throw err;
}
}
_registerOption(option) {
const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
if (matchingOption) {
const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
- already used by option '${matchingOption.flags}'`);
}
this.options.push(option);
}
_registerCommand(command) {
const knownBy = (cmd)=>[
cmd.name()
].concat(cmd.aliases());
const alreadyUsed = knownBy(command).find((name)=>this._findCommand(name));
if (alreadyUsed) {
const existingCmd = knownBy(this._findCommand(alreadyUsed)).join('|');
const newCmd = knownBy(command).join('|');
throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
}
this.commands.push(command);
}
addOption(option) {
this._registerOption(option);
const oname = option.name();
const name = option.attributeName();
if (option.negate) {
const positiveLongFlag = option.long.replace(/^--no-/, '--');
if (!this._findOption(positiveLongFlag)) this.setOptionValueWithSource(name, void 0 === option.defaultValue ? true : option.defaultValue, 'default');
} else if (void 0 !== option.defaultValue) this.setOptionValueWithSource(name, option.defaultValue, 'default');
const handleOptionValue = (val, invalidValueMessage, valueSource)=>{
if (null == val && void 0 !== option.presetArg) val = option.presetArg;
const oldValue = this.getOptionValue(name);
if (null !== val && option.parseArg) val = this._callParseArg(option, val, oldValue, invalidValueMessage);
else if (null !== val && option.variadic) val = option._concatValue(val, oldValue);
if (null == val) val = option.negate ? false : option.isBoolean() || option.optional ? true : '';
this.setOptionValueWithSource(name, val, valueSource);
};
this.on('option:' + oname, (val)=>{
const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
handleOptionValue(val, invalidValueMessage, 'cli');
});
if (option.envVar) this.on('optionEnv:' + oname, (val)=>{
const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
handleOptionValue(val, invalidValueMessage, 'env');
});
return this;
}
_optionEx(config, flags, description, fn, defaultValue) {
if ('object' == typeof flags && flags instanceof Option) throw new Error('To add an Option object use addOption() instead of option() or requiredOption()');
const option = this.createOption(flags, description);
option.makeOptionMandatory(!!config.mandatory);
if ('function' == typeof fn) option.default(defaultValue).argParser(fn);
else if (fn instanceof RegExp) {
const regex = fn;
fn = (val, def)=>{
const m = regex.exec(val);
return m ? m[0] : def;
};
option.default(defaultValue).argParser(fn);
} else option.default(fn);
return this.addOption(option);
}
option(flags, description, parseArg, defaultValue) {
return this._optionEx({}, flags, description, parseArg, defaultValue);
}
requiredOption(flags, description, parseArg, defaultValue) {
return this._optionEx({
mandatory: true
}, flags, description, parseArg, defaultValue);
}
combineFlagAndOptionalValue(combine = true) {
this._combineFlagAndOptionalValue = !!combine;
return this;
}
allowUnknownOption(allowUnknown = true) {
this._allowUnknownOption = !!allowUnknown;
return this;
}
allowExcessArguments(allowExcess = true) {
this._allowExcessArguments = !!allowExcess;
return this;
}
enablePositionalOptions(positional = true) {
this._enablePositionalOptions = !!positional;
return this;
}
passThroughOptions(passThrough = true) {
this._passThroughOptions = !!passThrough;
this._checkForBrokenPassThrough();
return this;
}
_checkForBrokenPassThrough() {
if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
}
storeOptionsAsProperties(storeAsProperties = true) {
if (this.options.length) throw new Error('call .storeOptionsAsProperties() before adding options');
if (Object.keys(this._optionValues).length) throw new Error('call .storeOptionsAsProperties() before setting option values');
this._storeOptionsAsProperties = !!storeAsProperties;
return this;
}
getOptionValue(key) {
if (this._storeOptionsAsProperties) return this[key];
return this._optionValues[key];
}
setOptionValue(key, value) {
return this.setOptionValueWithSource(key, value, void 0);
}
setOptionValueWithSource(key, value, source) {
if (this._storeOptionsAsProperties) this[key] = value;
else this._optionValues[key] = value;
this._optionValueSources[key] = source;
return this;
}
getOptionValueSource(key) {
return this._optionValueSources[key];
}
getOptionValueSourceWithGlobals(key) {
let source;
this._getCommandAndAncestors().forEach((cmd)=>{
if (void 0 !== cmd.getOptionValueSource(key)) source = cmd.getOptionValueSource(key);
});
return source;
}
_prepareUserArgs(argv, parseOptions) {
if (void 0 !== argv && !Array.isArray(argv)) throw new Error('first parameter to parse must be array or undefined');
parseOptions = parseOptions || {};
if (void 0 === argv && void 0 === parseOptions.from) {
if (process1.versions?.electron) parseOptions.from = 'electron';
const execArgv = process1.execArgv ?? [];
if (execArgv.includes('-e') || execArgv.includes('--eval') || execArgv.includes('-p') || execArgv.includes('--print')) parseOptions.from = 'eval';
}
if (void 0 === argv) argv = process1.argv;
this.rawArgs = argv.slice();
let userArgs;
switch(parseOptions.from){
case void 0:
case 'node':
this._scriptPath = argv[1];
userArgs = argv.slice(2);
break;
case 'electron':
if (process1.defaultApp) {
this._scriptPath = argv[1];
userArgs = argv.slice(2);
} else userArgs = argv.slice(1);
break;
case 'user':
userArgs = argv.slice(0);
break;
case 'eval':
userArgs = argv.slice(1);
break;
default:
throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
}
if (!this._name && this._scriptPath) this.nameFromFilename(this._scriptPath);
this._name = this._name || 'program';
return userArgs;
}
parse(argv, parseOptions) {
this._prepareForParse();
const userArgs = this._prepareUserArgs(argv, parseOptions);
this._parseCommand([], userArgs);
return this;
}
async parseAsync(argv, parseOptions) {
this._prepareForParse();
const userArgs = this._prepareUserArgs(argv, parseOptions);
await this._parseCommand([], userArgs);
return this;
}
_prepareForParse() {
if (null === this._savedState) this.saveStateBeforeParse();
else this.restoreStateBeforeParse();
}
saveStateBeforeParse() {
this._savedState = {
_name: this._name,
_optionValues: {
...this._optionValues
},
_optionValueSources: {
...this._optionValueSources
}
};
}
restoreStateBeforeParse() {
if (this._storeOptionsAsProperties) throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
- either make a new Command for each call to parse, or stop storing options as properties`);
this._name = this._savedState._name;
this._scriptPath = null;
this.rawArgs = [];
this._optionValues = {
...this._savedState._optionValues
};
this._optionValueSources = {
...this._savedState._optionValueSources
};
this.args = [];
this.processedArgs = [];
}
_checkForMissingExecutable(executableFile, executableDir, subcommandName) {
if (fs.existsSync(executableFile)) return;
const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
const executableMissing = `'${executableFile}' does not exist
- if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- ${executableDirMessage}`;
throw new Error(executableMissing);
}
_executeSubCommand(subcommand, args) {
args = args.slice();
let launchWithNode = false;
const sourceExt = [
'.js',
'.ts',
'.tsx',
'.mjs',
'.cjs'
];
function findFile(baseDir, baseName) {
const localBin = path.resolve(baseDir, baseName);
if (fs.existsSync(localBin)) return localBin;
if (sourceExt.includes(path.extname(baseName))) return;
const foundExt = sourceExt.find((ext)=>fs.existsSync(`${localBin}${ext}`));
if (foundExt) return `${localBin}${foundExt}`;
}
this._checkForMissingMandatoryOptions();
this._checkForConflictingOptions();
let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
let executableDir = this._executableDir || '';
if (this._scriptPath) {
let resolvedScriptPath;
try {
resolvedScriptPath = fs.realpathSync(this._scriptPath);
} catch {
resolvedScriptPath = this._scriptPath;
}
executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
}
if (executableDir) {
let localFile = findFile(executableDir, executableFile);
if (!localFile && !subcommand._executableFile && this._scriptPath) {
const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
if (legacyName !== this._name) localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
}
executableFile = localFile || executableFile;
}
launchWithNode = sourceExt.includes(path.extname(executableFile));
let proc;
if ('win32' !== process1.platform) if (launchWithNode) {
args.unshift(executableFile);
args = incrementNodeInspectorPort(process1.execArgv).concat(args);
proc = childProcess.spawn(process1.argv[0], args, {
stdio: 'inherit'
});
} else proc = childProcess.spawn(executableFile, args, {
stdio: 'inherit'
});
else {
this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
args.unshift(executableFile);
args = incrementNodeInspectorPort(process1.execArgv).concat(args);
proc = childProcess.spawn(process1.execPath, args, {
stdio: 'inherit'
});
}
if (!proc.killed) {
const signals = [
'SIGUSR1',
'SIGUSR2',
'SIGTERM',
'SIGINT',
'SIGHUP'
];
signals.forEach((signal)=>{
process1.on(signal, ()=>{
if (false === proc.killed && null === proc.exitCode) proc.kill(signal);
});
});
}
const exitCallback = this._exitCallback;
proc.on('close', (code)=>{
code = code ?? 1;
if (exitCallback) exitCallback(new CommanderError(code, 'commander.executeSubCommandAsync', '(close)'));
else process1.exit(code);
});
proc.on('error', (err)=>{
if ('ENOENT' === err.code) this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
else if ('EACCES' === err.code) throw new Error(`'${executableFile}' not executable`);
if (exitCallback) {
const wrappedError = new CommanderError(1, 'commander.executeSubCommandAsync', '(error)');
wrappedError.nestedError = err;
exitCallback(wrappedError);
} else process1.exit(1);
});
this.runningCommand = proc;
}
_dispatchSubcommand(commandName, operands, unknown) {
const subCommand = this._findCommand(commandName);
if (!subCommand) this.help({
error: true
});
subCommand._prepareForParse();
let promiseChain;
promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, 'preSubcommand');
promiseChain = this._chainOrCall(promiseChain, ()=>{
if (!subCommand._executableHandler) return subCommand._parseCommand(operands, unknown);
this._executeSubCommand(subCommand, operands.concat(unknown));
});
return promiseChain;
}
_dispatchHelpCommand(subcommandName) {
if (!subcommandName) this.help();
const subCommand = this._findCommand(subcommandName);
if (subCommand && !subCommand._executableHandler) subCommand.help();
return this._dispatchSubcommand(subcommandName, [], [
this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help'
]);
}
_checkNumberOfArguments() {
this.registeredArguments.forEach((arg, i)=>{
if (arg.required && null == this.args[i]) this.missingArgument(arg.name());
});
if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) return;
if (this.args.length > this.registeredArguments.length) this._excessArguments(this.args);
}
_processArguments() {
const myParseArg = (argument, value, previous)=>{
let parsedValue = value;
if (null !== value && argument.parseArg) {
const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
}
return parsedValue;
};
this._checkNumberOfArguments();
const processedArgs = [];
this.registeredArguments.forEach((declaredArg, index)=>{
let value = declaredArg.defaultValue;
if (declaredArg.variadic) {
if (index < this.args.length) {
value = this.args.slice(index);
if (declaredArg.parseArg) value = value.reduce((processed, v)=>myParseArg(declaredArg, v, processed), declaredArg.defaultValue);
} else if (void 0 === value) value = [];
} else if (index < this.args.length) {
value = this.args[index];
if (declaredArg.parseArg) value = myParseArg(declaredArg, value, declaredArg.defaultValue);
}
processedArgs[index] = value;
});
this.processedArgs = processedArgs;
}
_chainOrCall(promise, fn) {
if (promise && promise.then && 'function' == typeof promise.then) return promise.then(()=>fn());
return fn();
}
_chainOrCallHooks(promise, event) {
let result = promise;
const hooks = [];
this._getCommandAndAncestors().reverse().filter((cmd)=>void 0 !== cmd._lifeCycleHooks[event]).forEach((hookedCommand)=>{
hookedCommand._lifeCycleHooks[event].forEach((callback)=>{
hooks.push({
hookedCommand,
callback
});
});
});
if ('postAction' === event) hooks.reverse();
hooks.forEach((hookDetail)=>{
result = this._chainOrCall(result, ()=>hookDetail.callback(hookDetail.hookedCommand, this));
});
return result;
}
_chainOrCallSubCommandHook(promise, subCommand, event) {
let result = promise;
if (void 0 !== this._lifeCycleHooks[event]) this._lifeCycleHooks[event].forEach((hook)=>{
result = this._chainOrCall(result, ()=>hook(this, subCommand));
});
return result;
}
_parseCommand(operands, unknown) {
const parsed = this.parseOptions(unknown);
this._parseOptionsEnv();
this._parseOptionsImplied();
operands = operands.concat(parsed.operands);
unknown = parsed.unknown;
this.args = operands.concat(unknown);
if (operands && this._findCommand(operands[0])) return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) return this._dispatchHelpCommand(operands[1]);
if (this._defaultCommandName) {
this._outputHelpIfRequested(unknown);
return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
}
if (this.commands.length && 0 === this.args.length && !this._actionHandler && !this._defaultCommandName) this.help({
error: true
});
this._outputHelpIfRequested(parsed.unknown);
this._checkForMissingMandatoryOptions();
this._checkForConflictingOptions();
const checkForUnknownOptions = ()=>{
if (parsed.unknown.length > 0) this.unknownOption(parsed.unknown[0]);
};
const commandEvent = `command:${this.name()}`;
if (this._actionHandler) {
checkForUnknownOptions();
this._processArguments();
let promiseChain;
promiseChain = this._chainOrCallHooks(promiseChain, 'preAction');
promiseChain = this._chainOrCall(promiseChain, ()=>this._actionHandler(this.processedArgs));
if (this.parent) promiseChain = this._chainOrCall(promiseChain, ()=>{
this.parent.emit(commandEvent, operands, unknown);
});
promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');
return promiseChain;
}
if (this.parent && this.parent.listenerCount(commandEvent)) {
checkForUnknownOptions();
this._processArguments();
this.parent.emit(commandEvent, operands, unknown);
} else if (operands.length) {
if (this._findCommand('*')) return this._dispatchSubcommand('*', operands, unknown);
if (this.listenerCount('command:*')) this.emit('command:*', operands, unknown);
else if (this.commands.length) this.unknownCommand();
else {
checkForUnknownOptions();
this._processArguments();
}
} else if (this.commands.length) {
checkForUnknownOptions();
this.help({
error: true
});
} else {
checkForUnknownOptions();
this._processArguments();
}
}
_findCommand(name) {
if (!name) return;
return this.commands.find((cmd)=>cmd._name === name || cmd._aliases.includes(name));
}
_findOption(arg) {
return this.options.find((option)=>option.is(arg));
}
_checkForMissingMandatoryOptions() {
this._getCommandAndAncestors().forEach((cmd)=>{
cmd.options.forEach((anOption)=>{
if (anOption.mandatory && void 0 === cmd.getOptionValue(anOption.attributeName())) cmd.missingMandatoryOptionValue(anOption);
});
});
}
_checkForConflictingLocalOptions() {
const definedNonDefaultOptions = this.options.filter((option)=>{
const optionKey = option.attributeName();
if (void 0 === this.getOptionValue(optionKey)) return false;
return 'default' !== this.getOptionValueSource(optionKey);
});
const optionsWithConflicting = definedNonDefaultOptions.filter((option)=>option.conflictsWith.length > 0);
optionsWithConflicting.forEach((option)=>{
const conflictingAndDefined = definedNonDefaultOptions.find((defined)=>option.conflictsWith.includes(defined.attributeName()));
if (conflictingAndDefined) this._conflictingOption(option, conflictingAndDefined);
});
}
_checkForConflictingOptions() {
this._getCommandAndAncestors().forEach((cmd)=>{
cmd._checkForConflictingLocalOptions();
});
}
parseOptions(argv) {
const operands = [];
const unknown = [];
let dest = operands;
const args = argv.slice();
function maybeOption(arg) {
return arg.length > 1 && '-' === arg[0];
}
let activeVariadicOption = null;
while(args.length){
const arg = args.shift();
if ('--' === arg) {
if (dest === unknown) dest.push(arg);
dest.push(...args);
break;
}
if (activeVariadicOption && !maybeOption(arg)) {
this.emit(`option:${activeVariadicOption.name()}`, arg);
continue;
}
activeVariadicOption = null;
if (maybeOption(arg)) {
const option = this._findOption(arg);
if (option) {
if (option.required) {
const value = args.shift();
if (void 0 === value) this.optionMissingArgument(option);
this.emit(`option:${option.name()}`, value);
} else if (option.optional) {
let value = null;
if (args.length > 0 && !maybeOption(args[0])) value = args.shift();
this.emit(`option:${option.name()}`, value);
} else this.emit(`option:${option.name()}`);
activeVariadicOption = option.variadic ? option : null;
continue;
}
}
if (arg.length > 2 && '-' === arg[0] && '-' !== arg[1]) {
const option = this._findOption(`-${arg[1]}`);
if (option) {
if (option.required || option.optional && this._combineFlagAndOptionalValue) this.emit(`option:${option.name()}`, arg.slice(2));
else {
this.emit(`option:${option.name()}`);
args.unshift(`-${arg.slice(2)}`);
}
continue;
}
}
if (/^--[^=]+=/.test(arg)) {
const index = arg.indexOf('=');
const option = this._findOption(arg.slice(0, index));
if (option && (option.required || option.optional)) {
this.emit(`option:${option.name()}`, arg.slice(index + 1));
continue;
}
}
if (maybeOption(arg)) dest = unknown;
if ((this._enablePositionalOptions || this._passThroughOptions) && 0 === operands.length && 0 === unknown.length) {
if (this._findCommand(arg)) {
operands.push(arg);
if (args.length > 0) unknown.push(...args);
break;
} else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
operands.push(arg);
if (args.length > 0) operands.push(...args);
break;
} else if (this._defaultCommandName) {
unknown.push(arg);
if (args.length > 0) unknown.push(...args);
break;
}
}
if (this._passThroughOptions) {
dest.push(arg);
if (args.length > 0) dest.push(...args);
break;
}
dest.push(arg);
}
return {
operands,
unknown
};
}
opts() {
if (this._storeOptionsAsProperties) {
const result = {};
const len = this.options.length;
for(let i = 0; i < len; i++){
const key = this.options[i].attributeName();
result[key] = key === this._versionOptionName ? this._version : this[key];
}
return result;
}
return this._optionValues;
}
optsWithGlobals() {
return this._getCommandAndAncestors().reduce((combinedOptions, cmd)=>Object.assign(combinedOptions, cmd.opts()), {});
}
error(message, errorOptions) {
this._outputConfiguration.outputError(`${message}\n`, this._outputConfiguration.writeErr);
if ('string' == typeof this._showHelpAfterError) this._outputConfiguration.writeErr(`${this._showHelpAfterError}\n`);
else if (this._showHelpAfterError) {
this._outputConfiguration.writeErr('\n');
this.outputHelp({
error: true
});
}
const config = errorOptions || {};
const exitCode = config.exitCode || 1;
const code = config.code || 'commander.error';
this._exit(exitCode, code, message);
}
_parseOptionsEnv() {
this.options.forEach((option)=>{
if (option.envVar && option.envVar in process1.env) {
const optionKey = option.attributeName();
if (void 0 === this.getOptionValue(optionKey) || [
'default',
'config',
'env'
].includes(this.getOptionValueSource(optionKey))) if (option.required || option.optional) this.emit(`optionEnv:${option.name()}`, process1.env[option.envVar]);
else this.emit(`optionEnv:${option.name()}`);
}
});
}
_parseOptionsImplied() {
const dualHelper = new DualOptions(this.options);
const hasCustomOptionValue = (optionKey)=>void 0 !== this.getOptionValue(optionKey) && ![
'default',
'implied'
].includes(this.getOptionValueSource(optionKey));
this.options.filter((option)=>void 0 !== option.implied && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option)=>{
Object.keys(option.implied).filter((impliedKey)=>!hasCustomOptionValue(impliedKey)).forEach((impliedKey)=>{
this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], 'implied');
});
});
}
missingArgument(name) {
const message = `error: missing required argument '${name}'`;
this.error(message, {
code: 'commander.missingArgument'
});
}
optionMissingArgument(option) {
const message = `error: option '${option.flags}' argument missing`;
this.error(message, {
code: 'commander.optionMissingArgument'
});
}
missingMandatoryOptionValue(option) {
const message = `error: required option '${option.flags}' not specified`;
this.error(message, {
code: 'commander.missingMandatoryOptionValue'
});
}
_conflictingOption(option, conflictingOption) {
const findBestOptionFromValue = (option)=>{
const optionKey = option.attributeName();
const optionValue = this.getOptionValue(optionKey);
const negativeOption = this.options.find((target)=>target.negate && optionKey === target.attributeName());
const positiveOption = this.options.find((target)=>!target.negate && optionKey === target.attributeName());
if (negativeOption && (void 0 === negativeOption.presetArg && false === optionValue || void 0 !== negativeOption.presetArg && optionValue === negativeOption.presetArg)) return negativeOption;
return positiveOption || option;
};
const getErrorMessage = (option)=>{
const bestOption = findBestOptionFromValue(option);
const optionKey = bestOption.attributeName();
const source = this.getOptionValueSource(optionKey);
if ('env' === source) return `environment variable '${bestOption.envVar}'`;
return `option '${bestOption.flags}'`;
};
const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
this.error(message, {
code: 'commander.conflictingOption'
});
}
unknownOption(flag) {
if (this._allowUnknownOption) return;
let suggestion = '';
if (flag.startsWith('--') && this._showSuggestionAfterError) {
let candidateFlags = [];
let command = this;
do {
const moreFlags = command.createHelp().visibleOptions(command).filter((option)=>option.long).map((option)=>option.long);
candidateFlags = candidateFlags.concat(moreFlags);
command = command.parent;
}while (command && !command._enablePositionalOptions);
suggestion = suggestSimilar(flag, candidateFlags);
}
const message = `error: unknown option '${flag}'${suggestion}`;
this.error(message, {
code: 'commander.unknownOption'
});
}
_excessArguments(receivedArgs) {
if (this._allowExcessArguments) return;
const expected = this.registeredArguments.length;
const s = 1 === expected ? '' : 's';
const forSubcommand = this.parent ? ` for '${this.name()}'` : '';
const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
this.error(message, {
code: 'commander.excessArguments'
});
}
unknownCommand() {
const unknownName = this.args[0];
let suggestion = '';
if (this._showSuggestionAfterError) {
const candidateNames = [];
this.createHelp().visibleCommands(this).forEach((command)=>{
candidateNames.push(command.name());
if (command.alias()) candidateNames.push(command.alias());
});
suggestion = suggestSimilar(unknownName, candidateNames);
}
const message = `error: unknown command '${unknownName}'${suggestion}`;
this.error(message, {
code: 'commander.unknownCommand'
});
}
version(str, flags, description) {
if (void 0 === str) return this._version;
this._version = str;
flags = flags || '-V, --version';
description = description || 'output the version number';
const versionOption = this.createOption(flags, description);
this._versionOptionName = versionOption.attributeName();
this._registerOption(versionOption);
this.on('option:' + versionOption.name(), ()=>{
this._outputConfiguration.writeOut(`${str}\n`);
this._exit(0, 'commander.version', str);
});
return this;
}
description(str, argsDescription) {
if (void 0 === str && void 0 === argsDescription) return this._description;
this._description = str;
if (argsDescription) this._argsDescription = argsDescription;
return this;
}
summary(str) {
if (void 0 === str) return this._summary;
this._summary = str;
return this;
}
alias(alias) {
if (void 0 === alias) return this._aliases[0];
let command = this;
if (0 !== this.commands.length && this.commands[this.commands.length - 1]._executableHandler) command = this.commands[this.commands.length - 1];
if (alias === command._name) throw new Error("Command alias can't be the same as its name");
const matchingCommand = this.parent?._findCommand(alias);
if (matchingCommand) {
const existingCmd = [
matchingCommand.name()
].concat(matchingCommand.aliases()).join('|');
throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
}
command._aliases.push(alias);
return this;
}
aliases(aliases) {
if (void 0 === aliases) return this._aliases;
aliases.forEach((alias)=>this.alias(alias));
return this;
}
usage(str) {
if (void 0 === str) {
if (this._usage) return this._usage;
const args = this.registeredArguments.map((arg)=>humanReadableArgName(arg));
return [].concat(this.options.length || null !== this._helpOption ? '[options]' : [], this.commands.length ? '[command]' : [], this.registeredArguments.length ? args : []).join(' ');
}
this._usage = str;
return this;
}
name(str) {
if (void 0 === str) return this._name;
this._name = str;
return this;
}
nameFromFilename(filename) {
this._name = path.basename(filename, path.extname(filename));
return this;
}
executableDir(path) {
if (void 0 === path) return this._executableDir;
this._executableDir = path;
return this;
}
helpInformation(contextOptions) {
const helper = this.createHelp();
const context = this._getOutputContext(contextOptions);
helper.prepareContext({
error: context.error,
helpWidth: context.helpWidth,
outputHasColors: context.hasColors
});
const text = helper.formatHelp(this, helper);
if (context.hasColors) return text;
return this._outputConfiguration.stripColor(text);
}
_getOutputContext(contextOptions) {
contextOptions = contextOptions || {};
const error = !!contextOptions.error;
let baseWrite;
let hasColors;
let helpWidth;
if (error) {
baseWrite = (str)=>this._outputConfiguration.writeErr(str);
hasColors = this._outputConfiguration.getErrHasColors();
helpWidth = this._outputConfiguration.getErrHelpWidth();
} else {
baseWrite = (str)=>this._outputConfiguration.writeOut(str);
hasColors = this._outputConfiguration.getOutHasColors();
helpWidth = this._outputConfiguration.getOutHelpWidth();
}
const write = (str)=>{
if (!hasColors) str = this._outputConfiguration.stripColor(str);
return baseWrite(str);
};
return {
error,
write,
hasColors,
helpWidth
};
}
outputHelp(contextOptions) {
let deprecatedCallback;
if ('function' == typeof contextOptions) {
deprecatedCallback = contextOptions;
contextOptions = void 0;
}
const outputContext = this._getOutputContext(contextOptions);
const eventContext = {
error: outputContext.error,
write: outputContext.write,
command: this
};
this._getCommandAndAncestors().reverse().forEach((command)=>command.emit('beforeAllHelp', eventContext));
this.emit('beforeHelp', eventContext);
let helpInformation = this.helpInformation({
error: outputContext.error
});
if (deprecatedCallback) {
helpInformation = deprecatedCallback(helpInformation);
if ('string' != typeof helpInformation && !Buffer.isBuffer(helpInformation)) throw new Error('outputHelp callback must return a string or a Buffer');
}
outputContext.write(helpInformation);
if (this._getHelpOption()?.long) this.emit(this._getHelpOption().long);
this.emit('afterHelp', eventContext);
this._getCommandAndAncestors().forEach((command)=>command.emit('afterAllHelp', eventContext));
}
helpOption(flags, description) {
if ('boolean' == typeof flags) {
if (flags) this._helpOption = this._helpOption ?? void 0;
else this._helpOption = null;
return this;
}
flags = flags ?? '-h, --help';
description = description ?? 'display help for command';
this._helpOption = this.createOption(flags, description);
return this;
}
_getHelpOption() {
if (void 0 === this._helpOption) this.helpOption(void 0, void 0);
return this._helpOption;
}
addHelpOption(option) {
this._helpOption = option;
return this;
}
help(contextOptions) {
this.outputHelp(contextOptions);
let exitCode = Number(process1.exitCode ?? 0);
if (0 === exitCode && contextOptions && 'function' != typeof contextOptions && contextOptions.error) exitCode = 1;
this._exit(exitCode, 'commander.help', '(outputHelp)');
}
addHelpText(position, text) {
const allowedValues = [
'beforeAll',
'before',
'after',
'afterAll'
];
if (!allowedValues.includes(position)) throw new Error(`Unexpected value for position to addHelpText.
Expecting one of '${allowedValues.join("', '")}'`);
const helpEvent = `${position}Help`;
this.on(helpEvent, (context)=>{
let helpStr;
helpStr = 'function' == typeof text ? text({
error: context.error,
command: context.command
}) : text;
if (helpStr) context.write(`${helpStr}\n`);
});
return this;
}
_outputHelpIfRequested(args) {
const helpOption = this._getHelpOption();
const helpRequested = helpOption && args.find((arg)=>helpOption.is(arg));
if (helpRequested) {
this.outputHelp();
this._exit(0, 'commander.helpDisplayed', '(outputHelp)');
}
}
}
function incrementNodeInspectorPort(args) {
return args.map((arg)=>{
if (!arg.startsWith('--inspect')) return arg;
let debugOption;
let debugHost = '127.0.0.1';
let debugPort = '9229';
let match;
if (null !== (match = arg.match(/^(--inspect(-brk)?)$/))) debugOption = match[1];
else if (null !== (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/))) {
debugOption = match[1];
if (/^\d+$/.test(match[3])) debugPort = match[3];
else debugHost = match[3];
} else if (null !== (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/))) {
debugOption = match[1];
debugHost = match[3];
debugPort = match[4];
}
if (debugOption && '0' !== debugPort) return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
return arg;
});
}
function useColor() {
if (process1.env.NO_COLOR || '0' === process1.env.FORCE_COLOR || 'false' === process1.env.FORCE_COLOR) return false;
if (process1.env.FORCE_COLOR || void 0 !== process1.env.CLICOLOR_FORCE) return true;
}
exports.Command = Command;
exports.useColor = useColor;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js": function(__unused_webpack_module, exports) {
class CommanderError extends Error {
constructor(exitCode, code, message){
super(message);
Error.captureStackTrace(this, this.constructor);
this.name = this.constructor.name;
this.code = code;
this.exitCode = exitCode;
this.nestedError = void 0;
}
}
class InvalidArgumentError extends CommanderError {
constructor(message){
super(1, 'commander.invalidArgument', message);
Error.captureStackTrace(this, this.constructor);
this.name = this.constructor.name;
}
}
exports.CommanderError = CommanderError;
exports.InvalidArgumentError = InvalidArgumentError;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/help.js": function(__unused_webpack_module, exports, __webpack_require__) {
const { humanReadableArgName } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js");
class Help {
constructor(){
this.helpWidth = void 0;
this.minWidthToWrap = 40;
this.sortSubcommands = false;
this.sortOptions = false;
this.showGlobalOptions = false;
}
prepareContext(contextOptions) {
this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
}
visibleCommands(cmd) {
const visibleCommands = cmd.commands.filter((cmd)=>!cmd._hidden);
const helpCommand = cmd._getHelpCommand();
if (helpCommand && !helpCommand._hidden) visibleCommands.push(helpCommand);
if (this.sortSubcommands) visibleCommands.sort((a, b)=>a.name().localeCompare(b.name()));
return visibleCommands;
}
compareOptions(a, b) {
const getSortKey = (option)=>option.short ? option.short.replace(/^-/, '') : option.long.replace(/^--/, '');
return getSortKey(a).localeCompare(getSortKey(b));
}
visibleOptions(cmd) {
const visibleOptions = cmd.options.filter((option)=>!option.hidden);
const helpOption = cmd._getHelpOption();
if (helpOption && !helpOption.hidden) {
const removeShort = helpOption.short && cmd._findOption(helpOption.short);
const removeLong = helpOption.long && cmd._findOption(helpOption.long);
if (removeShort || removeLong) {
if (helpOption.long && !removeLong) visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
else if (helpOption.short && !removeShort) visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
} else visibleOptions.push(helpOption);
}
if (this.sortOptions) visibleOptions.sort(this.compareOptions);
return visibleOptions;
}
visibleGlobalOptions(cmd) {
if (!this.showGlobalOptions) return [];
const globalOptions = [];
for(let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent){
const visibleOptions = ancestorCmd.options.filter((option)=>!option.hidden);
globalOptions.push(...visibleOptions);
}
if (this.sortOptions) globalOptions.sort(this.compareOptions);
return globalOptions;
}
visibleArguments(cmd) {
if (cmd._argsDescription) cmd.registeredArguments.forEach((argument)=>{
argument.description = argument.description || cmd._argsDescription[argument.name()] || '';
});
if (cmd.registeredArguments.find((argument)=>argument.description)) return cmd.registeredArguments;
return [];
}
subcommandTerm(cmd) {
const args = cmd.registeredArguments.map((arg)=>humanReadableArgName(arg)).join(' ');
return cmd._name + (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') + (cmd.options.length ? ' [options]' : '') + (args ? ' ' + args : '');
}
optionTerm(option) {
return option.flags;
}
argumentTerm(argument) {
return argument.name();
}
longestSubcommandTermLength(cmd, helper) {
return helper.visibleCommands(cmd).reduce((max, command)=>Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command)))), 0);
}
longestOptionTermLength(cmd, helper) {
return helper.visibleOptions(cmd).reduce((max, option)=>Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))), 0);
}
longestGlobalOptionTermLength(cmd, helper) {
return helper.visibleGlobalOptions(cmd).reduce((max, option)=>Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))), 0);
}
longestArgumentTermLength(cmd, helper) {
return helper.visibleArguments(cmd).reduce((max, argument)=>Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument)))), 0);
}
commandUsage(cmd) {
let cmdName = cmd._name;
if (cmd._aliases[0]) cmdName = cmdName + '|' + cmd._aliases[0];
let ancestorCmdNames = '';
for(let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent)ancestorCmdNames = ancestorCmd.name() + ' ' + ancestorCmdNames;
return ancestorCmdNames + cmdName + ' ' + cmd.usage();
}
commandDescription(cmd) {
return cmd.description();
}
subcommandDescription(cmd) {
return cmd.summary() || cmd.description();
}
optionDescription(option) {
const extraInfo = [];
if (option.argChoices) extraInfo.push(`choices: ${option.argChoices.map((choice)=>JSON.stringify(choice)).join(', ')}`);
if (void 0 !== option.defaultValue) {
const showDefault = option.required || option.optional || option.isBoolean() && 'boolean' == typeof option.defaultValue;
if (showDefault) extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
}
if (void 0 !== option.presetArg && option.optional) extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
if (void 0 !== option.envVar) extraInfo.push(`env: ${option.envVar}`);
if (extraInfo.length > 0) return `${option.description} (${extraInfo.join(', ')})`;
return option.description;
}
argumentDescription(argument) {
const extraInfo = [];
if (argument.argChoices) extraInfo.push(`choices: ${argument.argChoices.map((choice)=>JSON.stringify(choice)).join(', ')}`);
if (void 0 !== argument.defaultValue) extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
if (extraInfo.length > 0) {
const extraDescription = `(${extraInfo.join(', ')})`;
if (argument.description) return `${argument.description} ${extraDescription}`;
return extraDescription;
}
return argument.description;
}
formatHelp(cmd, helper) {
const termWidth = helper.padWidth(cmd, helper);
const helpWidth = helper.helpWidth ?? 80;
function callFormatItem(term, description) {
return helper.formatItem(term, termWidth, description, helper);
}
let output = [
`${helper.styleTitle('Usage:')} ${helper.styleUsage(helper.commandUsage(cmd))}`,
''
];
const commandDescription = helper.commandDescription(cmd);
if (commandDescription.length > 0) output = output.concat([
helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
''
]);
const argumentList = helper.visibleArguments(cmd).map((argument)=>callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument))));
if (argumentList.length > 0) output = output.concat([
helper.styleTitle('Arguments:'),
...argumentList,
''
]);
const optionList = helper.visibleOptions(cmd).map((option)=>callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option))));
if (optionList.length > 0) output = output.concat([
helper.styleTitle('Options:'),
...optionList,
''
]);
if (helper.showGlobalOptions) {
const globalOptionList = helper.visibleGlobalOptions(cmd).map((option)=>callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option))));
if (globalOptionList.length > 0) output = output.concat([
helper.styleTitle('Global Options:'),
...globalOptionList,
''
]);
}
const commandList = helper.visibleCommands(cmd).map((cmd)=>callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd))));
if (commandList.length > 0) output = output.concat([
helper.styleTitle('Commands:'),
...commandList,
''
]);
return output.join('\n');
}
displayWidth(str) {
return stripColor(str).length;
}
styleTitle(str) {
return str;
}
styleUsage(str) {
return str.split(' ').map((word)=>{
if ('[options]' === word) return this.styleOptionText(word);
if ('[command]' === word) return this.styleSubcommandText(word);
if ('[' === word[0] || '<' === word[0]) return this.styleArgumentText(word);
return this.styleCommandText(word);
}).join(' ');
}
styleCommandDescription(str) {
return this.styleDescriptionText(str);
}
styleOptionDescription(str) {
return this.styleDescriptionText(str);
}
styleSubcommandDescription(str) {
return this.styleDescriptionText(str);
}
styleArgumentDescription(str) {
return this.styleDescriptionText(str);
}
styleDescriptionText(str) {
return str;
}
styleOptionTerm(str) {
return this.styleOptionText(str);
}
styleSubcommandTerm(str) {
return str.split(' ').map((word)=>{
if ('[options]' === word) return this.styleOptionText(word);
if ('[' === word[0] || '<' === word[0]) return this.styleArgumentText(word);
return this.styleSubcommandText(word);
}).join(' ');
}
styleArgumentTerm(str) {
return this.styleArgumentText(str);
}
styleOptionText(str) {
return str;
}
styleArgumentText(str) {
return str;
}
styleSubcommandText(str) {
return str;
}
styleCommandText(str) {
return str;
}
padWidth(cmd, helper) {
return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
}
preformatted(str) {
return /\n[^\S\r\n]/.test(str);
}
formatItem(term, termWidth, description, helper) {
const itemIndent = 2;
const itemIndentStr = ' '.repeat(itemIndent);
if (!description) return itemIndentStr + term;
const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
const spacerWidth = 2;
const helpWidth = this.helpWidth ?? 80;
const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
let formattedDescription;
if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) formattedDescription = description;
else {
const wrappedDescription = helper.boxWrap(description, remainingWidth);
formattedDescription = wrappedDescription.replace(/\n/g, '\n' + ' '.repeat(termWidth + spacerWidth));
}
return itemIndentStr + paddedTerm + ' '.repeat(spacerWidth) + formattedDescription.replace(/\n/g, `\n${itemIndentStr}`);
}
boxWrap(str, width) {
if (width < this.minWidthToWrap) return str;
const rawLines = str.split(/\r\n|\n/);
const chunkPattern = /[\s]*[^\s]+/g;
const wrappedLines = [];
rawLines.forEach((line)=>{
const chunks = line.match(chunkPattern);
if (null === chunks) return void wrappedLines.push('');
let sumChunks = [
chunks.shift()
];
let sumWidth = this.displayWidth(sumChunks[0]);
chunks.forEach((chunk)=>{
const visibleWidth = this.displayWidth(chunk);
if (sumWidth + visibleWidth <= width) {
sumChunks.push(chunk);
sumWidth += visibleWidth;
return;
}
wrappedLines.push(sumChunks.join(''));
const nextChunk = chunk.trimStart();
sumChunks = [
nextChunk
];
sumWidth = this.displayWidth(nextChunk);
});
wrappedLines.push(sumChunks.join(''));
});
return wrappedLines.join('\n');
}
}
function stripColor(str) {
const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
return str.replace(sgrPattern, '');
}
exports.Help = Help;
exports.stripColor = stripColor;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/option.js": function(__unused_webpack_module, exports, __webpack_require__) {
const { InvalidArgumentError } = __webpack_require__("../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js");
class Option {
constructor(flags, description){
this.flags = flags;
this.description = description || '';
this.required = flags.includes('<');
this.optional = flags.includes('[');
this.variadic = /\w\.\.\.[>\]]$/.test(flags);
this.mandatory = false;
const optionFlags = splitOptionFlags(flags);
this.short = optionFlags.shortFlag;
this.long = optionFlags.longFlag;
this.negate = false;
if (this.long) this.negate = this.long.startsWith('--no-');
this.defaultValue = void 0;
this.defaultValueDescription = void 0;
this.presetArg = void 0;
this.envVar = void 0;
this.parseArg = void 0;
this.hidden = false;
this.argChoices = void 0;
this.conflictsWith = [];
this.implied = void 0;
}
default(value, description) {
this.defaultValue = value;
this.defaultValueDescription = description;
return this;
}
preset(arg) {
this.presetArg = arg;
return this;
}
conflicts(names) {
this.conflictsWith = this.conflictsWith.concat(names);
return this;
}
implies(impliedOptionValues) {
let newImplied = impliedOptionValues;
if ('string' == typeof impliedOptionValues) newImplied = {
[impliedOptionValues]: true
};
this.implied = Object.assign(this.implied || {}, newImplied);
return this;
}
env(name) {
this.envVar = name;
return this;
}
argParser(fn) {
this.parseArg = fn;
return this;
}
makeOptionMandatory(mandatory = true) {
this.mandatory = !!mandatory;
return this;
}
hideHelp(hide = true) {
this.hidden = !!hide;
return this;
}
_concatValue(value, previous) {
if (previous === this.defaultValue || !Array.isArray(previous)) return [
value
];
return previous.concat(value);
}
choices(values) {
this.argChoices = values.slice();
this.parseArg = (arg, previous)=>{
if (!this.argChoices.includes(arg)) throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(', ')}.`);
if (this.variadic) return this._concatValue(arg, previous);
return arg;
};
return this;
}
name() {
if (this.long) return this.long.replace(/^--/, '');
return this.short.replace(/^-/, '');
}
attributeName() {
if (this.negate) return camelcase(this.name().replace(/^no-/, ''));
return camelcase(this.name());
}
is(arg) {
return this.short === arg || this.long === arg;
}
isBoolean() {
return !this.required && !this.optional && !this.negate;
}
}
class DualOptions {
constructor(options){
this.positiveOptions = new Map();
this.negativeOptions = new Map();
this.dualOptions = new Set();
options.forEach((option)=>{
if (option.negate) this.negativeOptions.set(option.attributeName(), option);
else this.positiveOptions.set(option.attributeName(), option);
});
this.negativeOptions.forEach((value, key)=>{
if (this.positiveOptions.has(key)) this.dualOptions.add(key);
});
}
valueFromOption(value, option) {
const optionKey = option.attributeName();
if (!this.dualOptions.has(optionKey)) return true;
const preset = this.negativeOptions.get(optionKey).presetArg;
const negativeValue = void 0 !== preset ? preset : false;
return option.negate === (negativeValue === value);
}
}
function camelcase(str) {
return str.split('-').reduce((str, word)=>str + word[0].toUpperCase() + word.slice(1));
}
function splitOptionFlags(flags) {
let shortFlag;
let longFlag;
const shortFlagExp = /^-[^-]$/;
const longFlagExp = /^--[^-]/;
const flagParts = flags.split(/[ |,]+/).concat('guard');
if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
if (!shortFlag && shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
if (!shortFlag && longFlagExp.test(flagParts[0])) {
shortFlag = longFlag;
longFlag = flagParts.shift();
}
if (flagParts[0].startsWith('-')) {
const unsupportedFlag = flagParts[0];
const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
if (/^-[^-][^-]/.test(unsupportedFlag)) throw new Error(`${baseError}
- a short flag is a single dash and a single character
- either use a single dash and a single character (for a short flag)
- or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
if (shortFlagExp.test(unsupportedFlag)) throw new Error(`${baseError}
- too many short flags`);
if (longFlagExp.test(unsupportedFlag)) throw new Error(`${baseError}
- too many long flags`);
throw new Error(`${baseError}
- unrecognised flag format`);
}
if (void 0 === shortFlag && void 0 === longFlag) throw new Error(`option creation failed due to no flags found in '${flags}'.`);
return {
shortFlag,
longFlag
};
}
exports.Option = Option;
exports.DualOptions = DualOptions;
},
"../../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js": function(__unused_webpack_module, exports) {
const maxDistance = 3;
function editDistance(a, b) {
if (Math.abs(a.length - b.length) > maxDistance) return Math.max(a.length, b.length);
const d = [];
for(let i = 0; i <= a.length; i++)d[i] = [
i
];
for(let j = 0; j <= b.length; j++)d[0][j] = j;
for(let j = 1; j <= b.length; j++)for(let i = 1; i <= a.length; i++){
let cost = 1;
cost = a[i - 1] === b[j - 1] ? 0 : 1;
d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
}
return d[a.length][b.length];
}
function suggestSimilar(word, candidates) {
if (!candidates || 0 === candidates.length) return '';
candidates = Array.from(new Set(candidates));
const searchingOptions = word.startsWith('--');
if (searchingOptions) {
word = word.slice(2);
candidates = candidates.map((candidate)=>candidate.slice(2));
}
let similar = [];
let bestDistance = maxDistance;
const minSimilarity = 0.4;
candidates.forEach((candidate)=>{
if (candidate.length <= 1) return;
const distance = editDistance(word, candidate);
const length = Math.max(word.length, candidate.length);
const similarity = (length - distance) / length;
if (similarity > minSimilarity) {
if (distance < bestDistance) {
bestDistance = distance;
similar = [
candidate
];
} else if (distance === bestDistance) similar.push(candidate);
}
});
similar.sort((a, b)=>a.localeCompare(b));
if (searchingOptions) similar = similar.map((candidate)=>`--${candidate}`);
if (similar.length > 1) return `\n(Did you mean one of ${similar.join(', ')}?)`;
if (1 === similar.length) return `\n(Did you mean ${similar[0]}?)`;
return '';
}
exports.suggestSimilar = suggestSimilar;
}
};
var __webpack_module_cache__ = {};
function __webpack_require__(moduleId) {
var cachedModule = __webpack_module_cache__[moduleId];
if (void 0 !== cachedModule) return cachedModule.exports;
var module = __webpack_module_cache__[moduleId] = {
exports: {}
};
__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
return module.exports;
}
(()=>{
var webpackQueues = "function" == typeof Symbol ? Symbol("webpack queues") : "__webpack_queues__";
var webpackExports = "function" == typeof Symbol ? Symbol("webpack exports") : "__webpack_exports__";
var webpackError = "function" == typeof Symbol ? Symbol("webpack error") : "__webpack_error__";
var resolveQueue = (queue)=>{
if (queue && queue.d < 1) {
queue.d = 1;
queue.forEach((fn)=>fn.r--);
queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
}
};
var wrapDeps = (deps)=>deps.map((dep)=>{
if (null !== dep && "object" == typeof dep) {
if (dep[webpackQueues]) return dep;
if (dep.then) {
var queue = [];
queue.d = 0;
dep.then((r)=>{
obj[webpackExports] = r;
resolveQueue(queue);
}, (e)=>{
obj[webpackError] = e;
resolveQueue(queue);
});
var obj = {};
obj[webpackQueues] = (fn)=>fn(queue);
return obj;
}
}
var ret = {};
ret[webpackQueues] = function() {};
ret[webpackExports] = dep;
return ret;
});
__webpack_require__.a = (module, body, hasAwait)=>{
var queue;
hasAwait && ((queue = []).d = -1);
var depQueues = new Set();
var exports = module.exports;
var currentDeps;
var outerResolve;
var reject;
var promise = new Promise((resolve, rej)=>{
reject = rej;
outerResolve = resolve;
});
promise[webpackExports] = exports;
promise[webpackQueues] = (fn)=>{
queue && fn(queue), depQueues.forEach(fn), promise["catch"](function() {});
};
module.exports = promise;
body((deps)=>{
currentDeps = wrapDeps(deps);
var fn;
var getResult = ()=>currentDeps.map((d)=>{
if (d[webpackError]) throw d[webpackError];
return d[webpackExports];
});
var promise = new Promise((resolve)=>{
fn = ()=>resolve(getResult);
fn.r = 0;
var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
currentDeps.map((dep)=>dep[webpackQueues](fnQueue));
});
return fn.r ? promise : getResult();
}, (err)=>(err ? reject(promise[webpackError] = err) : outerResolve(exports), resolveQueue(queue)));
queue && queue.d < 0 && (queue.d = 0);
};
})();
(()=>{
__webpack_require__.n = (module)=>{
var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
__webpack_require__.d(getter, {
a: getter
});
return getter;
};
})();
(()=>{
__webpack_require__.d = (exports, definition)=>{
for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
enumerable: true,
get: definition[key]
});
};
})();
(()=>{
__webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
__webpack_require__.r = (exports)=>{
if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
value: 'Module'
});
Object.defineProperty(exports, '__esModule', {
value: true
});
};
})();
__webpack_require__("./src/upgrade-rspeedy.ts");