wrangler
Version:
Command-line interface for all things Cloudflare Workers
1,268 lines (1,258 loc) • 6.71 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __esm = (fn2, res) => function __init() {
return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
};
var __commonJS = (cb2, mod) => function __require() {
return mod || (0, cb2[__getOwnPropNames(cb2)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all2) => {
for (var name2 in all2)
__defProp(target, name2, { get: all2[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// import_meta_url.js
var import_meta_url;
var init_import_meta_url = __esm({
"import_meta_url.js"() {
import_meta_url = require("url").pathToFileURL(__filename);
}
});
// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js
var YError;
var init_yerror = __esm({
"../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js"() {
init_import_meta_url();
YError = class _YError extends Error {
static {
__name(this, "YError");
}
constructor(msg) {
super(msg || "yargs error");
this.name = "YError";
if (Error.captureStackTrace) {
Error.captureStackTrace(this, _YError);
}
}
};
}
});
// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/apply-extends.js
function applyExtends(config, cwd2, mergeExtends, _shim) {
shim = _shim;
let defaultConfig = {};
if (Object.prototype.hasOwnProperty.call(config, "extends")) {
if (typeof config.extends !== "string")
return defaultConfig;
const isPath = /\.json|\..*rc$/.test(config.extends);
let pathToDefault = null;
if (!isPath) {
try {
pathToDefault = require.resolve(config.extends);
} catch (_err) {
return config;
}
} else {
pathToDefault = getPathToDefaultConfig(cwd2, config.extends);
}
checkForCircularExtends(pathToDefault);
previouslyVisitedConfigs.push(pathToDefault);
defaultConfig = isPath ? JSON.parse(shim.readFileSync(pathToDefault, "utf8")) : require(config.extends);
delete config.extends;
defaultConfig = applyExtends(defaultConfig, shim.path.dirname(pathToDefault), mergeExtends, shim);
}
previouslyVisitedConfigs = [];
return mergeExtends ? mergeDeep(defaultConfig, config) : Object.assign({}, defaultConfig, config);
}
function checkForCircularExtends(cfgPath) {
if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
throw new YError(`Circular extended configurations: '${cfgPath}'.`);
}
}
function getPathToDefaultConfig(cwd2, pathToExtend) {
return shim.path.resolve(cwd2, pathToExtend);
}
function mergeDeep(config1, config2) {
const target = {};
function isObject2(obj) {
return obj && typeof obj === "object" && !Array.isArray(obj);
}
__name(isObject2, "isObject");
Object.assign(target, config1);
for (const key of Object.keys(config2)) {
if (isObject2(config2[key]) && isObject2(target[key])) {
target[key] = mergeDeep(config1[key], config2[key]);
} else {
target[key] = config2[key];
}
}
return target;
}
var previouslyVisitedConfigs, shim;
var init_apply_extends = __esm({
"../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/apply-extends.js"() {
init_import_meta_url();
init_yerror();
previouslyVisitedConfigs = [];
__name(applyExtends, "applyExtends");
__name(checkForCircularExtends, "checkForCircularExtends");
__name(getPathToDefaultConfig, "getPathToDefaultConfig");
__name(mergeDeep, "mergeDeep");
}
});
// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/process-argv.js
function getProcessArgvBinIndex() {
if (isBundledElectronApp())
return 0;
return 1;
}
function isBundledElectronApp() {
return isElectronApp() && !process.defaultApp;
}
function isElectronApp() {
return !!process.versions.electron;
}
function hideBin(argv) {
return argv.slice(getProcessArgvBinIndex() + 1);
}
function getProcessArgvBin() {
return process.argv[getProcessArgvBinIndex()];
}
var init_process_argv = __esm({
"../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/process-argv.js"() {
init_import_meta_url();
__name(getProcessArgvBinIndex, "getProcessArgvBinIndex");
__name(isBundledElectronApp, "isBundledElectronApp");
__name(isElectronApp, "isElectronApp");
__name(hideBin, "hideBin");
__name(getProcessArgvBin, "getProcessArgvBin");
}
});
// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/string-utils.js
function camelCase(str) {
const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
if (!isCamelCase) {
str = str.toLowerCase();
}
if (str.indexOf("-") === -1 && str.indexOf("_") === -1) {
return str;
} else {
let camelcase = "";
let nextChrUpper = false;
const leadingHyphens = str.match(/^-+/);
for (let i5 = leadingHyphens ? leadingHyphens[0].length : 0; i5 < str.length; i5++) {
let chr = str.charAt(i5);
if (nextChrUpper) {
nextChrUpper = false;
chr = chr.toUpperCase();
}
if (i5 !== 0 && (chr === "-" || chr === "_")) {
nextChrUpper = true;
} else if (chr !== "-" && chr !== "_") {
camelcase += chr;
}
}
return camelcase;
}
}
function decamelize(str, joinString) {
const lowercase = str.toLowerCase();
joinString = joinString || "-";
let notCamelcase = "";
for (let i5 = 0; i5 < str.length; i5++) {
const chrLower = lowercase.charAt(i5);
const chrString = str.charAt(i5);
if (chrLower !== chrString && i5 > 0) {
notCamelcase += `${joinString}${lowercase.charAt(i5)}`;
} else {
notCamelcase += chrString;
}
}
return notCamelcase;
}
function looksLikeNumber(x6) {
if (x6 === null || x6 === void 0)
return false;
if (typeof x6 === "number")
return true;
if (/^0x[0-9a-f]+$/i.test(x6))
return true;
if (/^0[^.]/.test(x6))
return false;
return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x6);
}
var init_string_utils = __esm({
"../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/string-utils.js"() {
init_import_meta_url();
__name(camelCase, "camelCase");
__name(decamelize, "decamelize");
__name(looksLikeNumber, "looksLikeNumber");
}
});
// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/tokenize-arg-string.js
function tokenizeArgString(argString) {
if (Array.isArray(argString)) {
return argString.map((e7) => typeof e7 !== "string" ? e7 + "" : e7);
}
argString = argString.trim();
let i5 = 0;
let prevC = null;
let c6 = null;
let opening = null;
const args = [];
for (let ii = 0; ii < argString.length; ii++) {
prevC = c6;
c6 = argString.charAt(ii);
if (c6 === " " && !opening) {
if (!(prevC === " ")) {
i5++;
}
continue;
}
if (c6 === opening) {
opening = null;
} else if ((c6 === "'" || c6 === '"') && !opening) {
opening = c6;
}
if (!args[i5])
args[i5] = "";
args[i5] += c6;
}
return args;
}
var init_tokenize_arg_string = __esm({
"../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/tokenize-arg-string.js"() {
init_import_meta_url();
__name(tokenizeArgString, "tokenizeArgString");
}
});
// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser-types.js
var DefaultValuesForTypeKey;
var init_yargs_parser_types = __esm({
"../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser-types.js"() {
init_import_meta_url();
(function(DefaultValuesForTypeKey2) {
DefaultValuesForTypeKey2["BOOLEAN"] = "boolean";
DefaultValuesForTypeKey2["STRING"] = "string";
DefaultValuesForTypeKey2["NUMBER"] = "number";
DefaultValuesForTypeKey2["ARRAY"] = "array";
})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
}
});
// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser.js
function combineAliases(aliases2) {
const aliasArrays = [];
const combined = /* @__PURE__ */ Object.create(null);
let change = true;
Object.keys(aliases2).forEach(function(key) {
aliasArrays.push([].concat(aliases2[key], key));
});
while (change) {
change = false;
for (let i5 = 0; i5 < aliasArrays.length; i5++) {
for (let ii = i5 + 1; ii < aliasArrays.length; ii++) {
const intersect = aliasArrays[i5].filter(function(v7) {
return aliasArrays[ii].indexOf(v7) !== -1;
});
if (intersect.length) {
aliasArrays[i5] = aliasArrays[i5].concat(aliasArrays[ii]);
aliasArrays.splice(ii, 1);
change = true;
break;
}
}
}
}
aliasArrays.forEach(function(aliasArray) {
aliasArray = aliasArray.filter(function(v7, i5, self2) {
return self2.indexOf(v7) === i5;
});
const lastAlias = aliasArray.pop();
if (lastAlias !== void 0 && typeof lastAlias === "string") {
combined[lastAlias] = aliasArray;
}
});
return combined;
}
function increment(orig) {
return orig !== void 0 ? orig + 1 : 1;
}
function sanitizeKey(key) {
if (key === "__proto__")
return "___proto___";
return key;
}
function stripQuotes(val2) {
return typeof val2 === "string" && (val2[0] === "'" || val2[0] === '"') && val2[val2.length - 1] === val2[0] ? val2.substring(1, val2.length - 1) : val2;
}
var mixin, YargsParser;
var init_yargs_parser = __esm({
"../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser.js"() {
init_import_meta_url();
init_tokenize_arg_string();
init_yargs_parser_types();
init_string_utils();
YargsParser = class {
static {
__name(this, "YargsParser");
}
constructor(_mixin) {
mixin = _mixin;
}
parse(argsInput, options) {
const opts = Object.assign({
alias: void 0,
array: void 0,
boolean: void 0,
config: void 0,
configObjects: void 0,
configuration: void 0,
coerce: void 0,
count: void 0,
default: void 0,
envPrefix: void 0,
narg: void 0,
normalize: void 0,
string: void 0,
number: void 0,
__: void 0,
key: void 0
}, options);
const args = tokenizeArgString(argsInput);
const inputIsString = typeof argsInput === "string";
const aliases2 = combineAliases(Object.assign(/* @__PURE__ */ Object.create(null), opts.alias));
const configuration = Object.assign({
"boolean-negation": true,
"camel-case-expansion": true,
"combine-arrays": false,
"dot-notation": true,
"duplicate-arguments-array": true,
"flatten-duplicate-arrays": true,
"greedy-arrays": true,
"halt-at-non-option": false,
"nargs-eats-options": false,
"negation-prefix": "no-",
"parse-numbers": true,
"parse-positional-numbers": true,
"populate--": false,
"set-placeholder-key": false,
"short-option-groups": true,
"strip-aliased": false,
"strip-dashed": false,
"unknown-options-as-args": false
}, opts.configuration);
const defaults = Object.assign(/* @__PURE__ */ Object.create(null), opts.default);
const configObjects = opts.configObjects || [];
const envPrefix = opts.envPrefix;
const notFlagsOption = configuration["populate--"];
const notFlagsArgv = notFlagsOption ? "--" : "_";
const newAliases = /* @__PURE__ */ Object.create(null);
const defaulted = /* @__PURE__ */ Object.create(null);
const __ = opts.__ || mixin.format;
const flags2 = {
aliases: /* @__PURE__ */ Object.create(null),
arrays: /* @__PURE__ */ Object.create(null),
bools: /* @__PURE__ */ Object.create(null),
strings: /* @__PURE__ */ Object.create(null),
numbers: /* @__PURE__ */ Object.create(null),
counts: /* @__PURE__ */ Object.create(null),
normalize: /* @__PURE__ */ Object.create(null),
configs: /* @__PURE__ */ Object.create(null),
nargs: /* @__PURE__ */ Object.create(null),
coercions: /* @__PURE__ */ Object.create(null),
keys: []
};
const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
const negatedBoolean = new RegExp("^--" + configuration["negation-prefix"] + "(.+)");
[].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
const key = typeof opt === "object" ? opt.key : opt;
const assignment = Object.keys(opt).map(function(key2) {
const arrayFlagKeys = {
boolean: "bools",
string: "strings",
number: "numbers"
};
return arrayFlagKeys[key2];
}).filter(Boolean).pop();
if (assignment) {
flags2[assignment][key] = true;
}
flags2.arrays[key] = true;
flags2.keys.push(key);
});
[].concat(opts.boolean || []).filter(Boolean).forEach(function(key) {
flags2.bools[key] = true;
flags2.keys.push(key);
});
[].concat(opts.string || []).filter(Boolean).forEach(function(key) {
flags2.strings[key] = true;
flags2.keys.push(key);
});
[].concat(opts.number || []).filter(Boolean).forEach(function(key) {
flags2.numbers[key] = true;
flags2.keys.push(key);
});
[].concat(opts.count || []).filter(Boolean).forEach(function(key) {
flags2.counts[key] = true;
flags2.keys.push(key);
});
[].concat(opts.normalize || []).filter(Boolean).forEach(function(key) {
flags2.normalize[key] = true;
flags2.keys.push(key);
});
if (typeof opts.narg === "object") {
Object.entries(opts.narg).forEach(([key, value]) => {
if (typeof value === "number") {
flags2.nargs[key] = value;
flags2.keys.push(key);
}
});
}
if (typeof opts.coerce === "object") {
Object.entries(opts.coerce).forEach(([key, value]) => {
if (typeof value === "function") {
flags2.coercions[key] = value;
flags2.keys.push(key);
}
});
}
if (typeof opts.config !== "undefined") {
if (Array.isArray(opts.config) || typeof opts.config === "string") {
;
[].concat(opts.config).filter(Boolean).forEach(function(key) {
flags2.configs[key] = true;
});
} else if (typeof opts.config === "object") {
Object.entries(opts.config).forEach(([key, value]) => {
if (typeof value === "boolean" || typeof value === "function") {
flags2.configs[key] = value;
}
});
}
}
extendAliases(opts.key, aliases2, opts.default, flags2.arrays);
Object.keys(defaults).forEach(function(key) {
(flags2.aliases[key] || []).forEach(function(alias) {
defaults[alias] = defaults[key];
});
});
let error2 = null;
checkConfiguration();
let notFlags = [];
const argv = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] });
const argvReturn = {};
for (let i5 = 0; i5 < args.length; i5++) {
const arg = args[i5];
const truncatedArg = arg.replace(/^-{3,}/, "---");
let broken;
let key;
let letters;
let m6;
let next;
let value;
if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
pushPositional(arg);
} else if (truncatedArg.match(/^---+(=|$)/)) {
pushPositional(arg);
continue;
} else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
m6 = arg.match(/^--?([^=]+)=([\s\S]*)$/);
if (m6 !== null && Array.isArray(m6) && m6.length >= 3) {
if (checkAllAliases(m6[1], flags2.arrays)) {
i5 = eatArray(i5, m6[1], args, m6[2]);
} else if (checkAllAliases(m6[1], flags2.nargs) !== false) {
i5 = eatNargs(i5, m6[1], args, m6[2]);
} else {
setArg(m6[1], m6[2], true);
}
}
} else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
m6 = arg.match(negatedBoolean);
if (m6 !== null && Array.isArray(m6) && m6.length >= 2) {
key = m6[1];
setArg(key, checkAllAliases(key, flags2.arrays) ? [false] : false);
}
} else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
m6 = arg.match(/^--?(.+)/);
if (m6 !== null && Array.isArray(m6) && m6.length >= 2) {
key = m6[1];
if (checkAllAliases(key, flags2.arrays)) {
i5 = eatArray(i5, key, args);
} else if (checkAllAliases(key, flags2.nargs) !== false) {
i5 = eatNargs(i5, key, args);
} else {
next = args[i5 + 1];
if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags2.bools) && !checkAllAliases(key, flags2.counts)) {
setArg(key, next);
i5++;
} else if (/^(true|false)$/.test(next)) {
setArg(key, next);
i5++;
} else {
setArg(key, defaultValue(key));
}
}
}
} else if (arg.match(/^-.\..+=/)) {
m6 = arg.match(/^-([^=]+)=([\s\S]*)$/);
if (m6 !== null && Array.isArray(m6) && m6.length >= 3) {
setArg(m6[1], m6[2]);
}
} else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
next = args[i5 + 1];
m6 = arg.match(/^-(.\..+)/);
if (m6 !== null && Array.isArray(m6) && m6.length >= 2) {
key = m6[1];
if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags2.bools) && !checkAllAliases(key, flags2.counts)) {
setArg(key, next);
i5++;
} else {
setArg(key, defaultValue(key));
}
}
} else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
letters = arg.slice(1, -1).split("");
broken = false;
for (let j6 = 0; j6 < letters.length; j6++) {
next = arg.slice(j6 + 2);
if (letters[j6 + 1] && letters[j6 + 1] === "=") {
value = arg.slice(j6 + 3);
key = letters[j6];
if (checkAllAliases(key, flags2.arrays)) {
i5 = eatArray(i5, key, args, value);
} else if (checkAllAliases(key, flags2.nargs) !== false) {
i5 = eatNargs(i5, key, args, value);
} else {
setArg(key, value);
}
broken = true;
break;
}
if (next === "-") {
setArg(letters[j6], next);
continue;
}
if (/[A-Za-z]/.test(letters[j6]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags2.bools) === false) {
setArg(letters[j6], next);
broken = true;
break;
}
if (letters[j6 + 1] && letters[j6 + 1].match(/\W/)) {
setArg(letters[j6], next);
broken = true;
break;
} else {
setArg(letters[j6], defaultValue(letters[j6]));
}
}
key = arg.slice(-1)[0];
if (!broken && key !== "-") {
if (checkAllAliases(key, flags2.arrays)) {
i5 = eatArray(i5, key, args);
} else if (checkAllAliases(key, flags2.nargs) !== false) {
i5 = eatNargs(i5, key, args);
} else {
next = args[i5 + 1];
if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags2.bools) && !checkAllAliases(key, flags2.counts)) {
setArg(key, next);
i5++;
} else if (/^(true|false)$/.test(next)) {
setArg(key, next);
i5++;
} else {
setArg(key, defaultValue(key));
}
}
}
} else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags2.bools)) {
key = arg.slice(1);
setArg(key, defaultValue(key));
} else if (arg === "--") {
notFlags = args.slice(i5 + 1);
break;
} else if (configuration["halt-at-non-option"]) {
notFlags = args.slice(i5);
break;
} else {
pushPositional(arg);
}
}
applyEnvVars(argv, true);
applyEnvVars(argv, false);
setConfig(argv);
setConfigObjects();
applyDefaultsAndAliases(argv, flags2.aliases, defaults, true);
applyCoercions(argv);
if (configuration["set-placeholder-key"])
setPlaceholderKeys(argv);
Object.keys(flags2.counts).forEach(function(key) {
if (!hasKey2(argv, key.split(".")))
setArg(key, 0);
});
if (notFlagsOption && notFlags.length)
argv[notFlagsArgv] = [];
notFlags.forEach(function(key) {
argv[notFlagsArgv].push(key);
});
if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) {
Object.keys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
delete argv[key];
});
}
if (configuration["strip-aliased"]) {
;
[].concat(...Object.keys(aliases2).map((k6) => aliases2[k6])).forEach((alias) => {
if (configuration["camel-case-expansion"] && alias.includes("-")) {
delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
}
delete argv[alias];
});
}
function pushPositional(arg) {
const maybeCoercedNumber = maybeCoerceNumber("_", arg);
if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") {
argv._.push(maybeCoercedNumber);
}
}
__name(pushPositional, "pushPositional");
function eatNargs(i5, key, args2, argAfterEqualSign) {
let ii;
let toEat = checkAllAliases(key, flags2.nargs);
toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
if (toEat === 0) {
if (!isUndefined(argAfterEqualSign)) {
error2 = Error(__("Argument unexpected for: %s", key));
}
setArg(key, defaultValue(key));
return i5;
}
let available = isUndefined(argAfterEqualSign) ? 0 : 1;
if (configuration["nargs-eats-options"]) {
if (args2.length - (i5 + 1) + available < toEat) {
error2 = Error(__("Not enough arguments following: %s", key));
}
available = toEat;
} else {
for (ii = i5 + 1; ii < args2.length; ii++) {
if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii]))
available++;
else
break;
}
if (available < toEat)
error2 = Error(__("Not enough arguments following: %s", key));
}
let consumed = Math.min(available, toEat);
if (!isUndefined(argAfterEqualSign) && consumed > 0) {
setArg(key, argAfterEqualSign);
consumed--;
}
for (ii = i5 + 1; ii < consumed + i5 + 1; ii++) {
setArg(key, args2[ii]);
}
return i5 + consumed;
}
__name(eatNargs, "eatNargs");
function eatArray(i5, key, args2, argAfterEqualSign) {
let argsToSet = [];
let next = argAfterEqualSign || args2[i5 + 1];
const nargsCount = checkAllAliases(key, flags2.nargs);
if (checkAllAliases(key, flags2.bools) && !/^(true|false)$/.test(next)) {
argsToSet.push(true);
} else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
if (defaults[key] !== void 0) {
const defVal = defaults[key];
argsToSet = Array.isArray(defVal) ? defVal : [defVal];
}
} else {
if (!isUndefined(argAfterEqualSign)) {
argsToSet.push(processValue(key, argAfterEqualSign, true));
}
for (let ii = i5 + 1; ii < args2.length; ii++) {
if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount)
break;
next = args2[ii];
if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
break;
i5 = ii;
argsToSet.push(processValue(key, next, inputIsString));
}
}
if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) {
error2 = Error(__("Not enough arguments following: %s", key));
}
setArg(key, argsToSet);
return i5;
}
__name(eatArray, "eatArray");
function setArg(key, val2, shouldStripQuotes = inputIsString) {
if (/-/.test(key) && configuration["camel-case-expansion"]) {
const alias = key.split(".").map(function(prop) {
return camelCase(prop);
}).join(".");
addNewAlias(key, alias);
}
const value = processValue(key, val2, shouldStripQuotes);
const splitKey = key.split(".");
setKey(argv, splitKey, value);
if (flags2.aliases[key]) {
flags2.aliases[key].forEach(function(x6) {
const keyProperties = x6.split(".");
setKey(argv, keyProperties, value);
});
}
if (splitKey.length > 1 && configuration["dot-notation"]) {
;
(flags2.aliases[splitKey[0]] || []).forEach(function(x6) {
let keyProperties = x6.split(".");
const a5 = [].concat(splitKey);
a5.shift();
keyProperties = keyProperties.concat(a5);
if (!(flags2.aliases[key] || []).includes(keyProperties.join("."))) {
setKey(argv, keyProperties, value);
}
});
}
if (checkAllAliases(key, flags2.normalize) && !checkAllAliases(key, flags2.arrays)) {
const keys = [key].concat(flags2.aliases[key] || []);
keys.forEach(function(key2) {
Object.defineProperty(argvReturn, key2, {
enumerable: true,
get() {
return val2;
},
set(value2) {
val2 = typeof value2 === "string" ? mixin.normalize(value2) : value2;
}
});
});
}
}
__name(setArg, "setArg");
function addNewAlias(key, alias) {
if (!(flags2.aliases[key] && flags2.aliases[key].length)) {
flags2.aliases[key] = [alias];
newAliases[alias] = true;
}
if (!(flags2.aliases[alias] && flags2.aliases[alias].length)) {
addNewAlias(alias, key);
}
}
__name(addNewAlias, "addNewAlias");
function processValue(key, val2, shouldStripQuotes) {
if (shouldStripQuotes) {
val2 = stripQuotes(val2);
}
if (checkAllAliases(key, flags2.bools) || checkAllAliases(key, flags2.counts)) {
if (typeof val2 === "string")
val2 = val2 === "true";
}
let value = Array.isArray(val2) ? val2.map(function(v7) {
return maybeCoerceNumber(key, v7);
}) : maybeCoerceNumber(key, val2);
if (checkAllAliases(key, flags2.counts) && (isUndefined(value) || typeof value === "boolean")) {
value = increment();
}
if (checkAllAliases(key, flags2.normalize) && checkAllAliases(key, flags2.arrays)) {
if (Array.isArray(val2))
value = val2.map((val3) => {
return mixin.normalize(val3);
});
else
value = mixin.normalize(val2);
}
return value;
}
__name(processValue, "processValue");
function maybeCoerceNumber(key, value) {
if (!configuration["parse-positional-numbers"] && key === "_")
return value;
if (!checkAllAliases(key, flags2.strings) && !checkAllAliases(key, flags2.bools) && !Array.isArray(value)) {
const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`)));
if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags2.numbers)) {
value = Number(value);
}
}
return value;
}
__name(maybeCoerceNumber, "maybeCoerceNumber");
function setConfig(argv2) {
const configLookup = /* @__PURE__ */ Object.create(null);
applyDefaultsAndAliases(configLookup, flags2.aliases, defaults);
Object.keys(flags2.configs).forEach(function(configKey) {
const configPath = argv2[configKey] || configLookup[configKey];
if (configPath) {
try {
let config = null;
const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
const resolveConfig2 = flags2.configs[configKey];
if (typeof resolveConfig2 === "function") {
try {
config = resolveConfig2(resolvedConfigPath);
} catch (e7) {
config = e7;
}
if (config instanceof Error) {
error2 = config;
return;
}
} else {
config = mixin.require(resolvedConfigPath);
}
setConfigObject(config);
} catch (ex) {
if (ex.name === "PermissionDenied")
error2 = ex;
else if (argv2[configKey])
error2 = Error(__("Invalid JSON config file: %s", configPath));
}
}
});
}
__name(setConfig, "setConfig");
function setConfigObject(config, prev) {
Object.keys(config).forEach(function(key) {
const value = config[key];
const fullKey = prev ? prev + "." + key : key;
if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
setConfigObject(value, fullKey);
} else {
if (!hasKey2(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags2.arrays) && configuration["combine-arrays"]) {
setArg(fullKey, value);
}
}
});
}
__name(setConfigObject, "setConfigObject");
function setConfigObjects() {
if (typeof configObjects !== "undefined") {
configObjects.forEach(function(configObject) {
setConfigObject(configObject);
});
}
}
__name(setConfigObjects, "setConfigObjects");
function applyEnvVars(argv2, configOnly) {
if (typeof envPrefix === "undefined")
return;
const prefix = typeof envPrefix === "string" ? envPrefix : "";
const env6 = mixin.env();
Object.keys(env6).forEach(function(envVar) {
if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
const keys = envVar.split("__").map(function(key, i5) {
if (i5 === 0) {
key = key.substring(prefix.length);
}
return camelCase(key);
});
if ((configOnly && flags2.configs[keys.join(".")] || !configOnly) && !hasKey2(argv2, keys)) {
setArg(keys.join("."), env6[envVar]);
}
}
});
}
__name(applyEnvVars, "applyEnvVars");
function applyCoercions(argv2) {
let coerce2;
const applied = /* @__PURE__ */ new Set();
Object.keys(argv2).forEach(function(key) {
if (!applied.has(key)) {
coerce2 = checkAllAliases(key, flags2.coercions);
if (typeof coerce2 === "function") {
try {
const value = maybeCoerceNumber(key, coerce2(argv2[key]));
[].concat(flags2.aliases[key] || [], key).forEach((ali) => {
applied.add(ali);
argv2[ali] = value;
});
} catch (err) {
error2 = err;
}
}
}
});
}
__name(applyCoercions, "applyCoercions");
function setPlaceholderKeys(argv2) {
flags2.keys.forEach((key) => {
if (~key.indexOf("."))
return;
if (typeof argv2[key] === "undefined")
argv2[key] = void 0;
});
return argv2;
}
__name(setPlaceholderKeys, "setPlaceholderKeys");
function applyDefaultsAndAliases(obj, aliases3, defaults2, canLog = false) {
Object.keys(defaults2).forEach(function(key) {
if (!hasKey2(obj, key.split("."))) {
setKey(obj, key.split("."), defaults2[key]);
if (canLog)
defaulted[key] = true;
(aliases3[key] || []).forEach(function(x6) {
if (hasKey2(obj, x6.split(".")))
return;
setKey(obj, x6.split("."), defaults2[key]);
});
}
});
}
__name(applyDefaultsAndAliases, "applyDefaultsAndAliases");
function hasKey2(obj, keys) {
let o5 = obj;
if (!configuration["dot-notation"])
keys = [keys.join(".")];
keys.slice(0, -1).forEach(function(key2) {
o5 = o5[key2] || {};
});
const key = keys[keys.length - 1];
if (typeof o5 !== "object")
return false;
else
return key in o5;
}
__name(hasKey2, "hasKey");
function setKey(obj, keys, value) {
let o5 = obj;
if (!configuration["dot-notation"])
keys = [keys.join(".")];
keys.slice(0, -1).forEach(function(key2) {
key2 = sanitizeKey(key2);
if (typeof o5 === "object" && o5[key2] === void 0) {
o5[key2] = {};
}
if (typeof o5[key2] !== "object" || Array.isArray(o5[key2])) {
if (Array.isArray(o5[key2])) {
o5[key2].push({});
} else {
o5[key2] = [o5[key2], {}];
}
o5 = o5[key2][o5[key2].length - 1];
} else {
o5 = o5[key2];
}
});
const key = sanitizeKey(keys[keys.length - 1]);
const isTypeArray = checkAllAliases(keys.join("."), flags2.arrays);
const isValueArray = Array.isArray(value);
let duplicate = configuration["duplicate-arguments-array"];
if (!duplicate && checkAllAliases(key, flags2.nargs)) {
duplicate = true;
if (!isUndefined(o5[key]) && flags2.nargs[key] === 1 || Array.isArray(o5[key]) && o5[key].length === flags2.nargs[key]) {
o5[key] = void 0;
}
}
if (value === increment()) {
o5[key] = increment(o5[key]);
} else if (Array.isArray(o5[key])) {
if (duplicate && isTypeArray && isValueArray) {
o5[key] = configuration["flatten-duplicate-arrays"] ? o5[key].concat(value) : (Array.isArray(o5[key][0]) ? o5[key] : [o5[key]]).concat([value]);
} else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
o5[key] = value;
} else {
o5[key] = o5[key].concat([value]);
}
} else if (o5[key] === void 0 && isTypeArray) {
o5[key] = isValueArray ? value : [value];
} else if (duplicate && !(o5[key] === void 0 || checkAllAliases(key, flags2.counts) || checkAllAliases(key, flags2.bools))) {
o5[key] = [o5[key], value];
} else {
o5[key] = value;
}
}
__name(setKey, "setKey");
function extendAliases(...args2) {
args2.forEach(function(obj) {
Object.keys(obj || {}).forEach(function(key) {
if (flags2.aliases[key])
return;
flags2.aliases[key] = [].concat(aliases2[key] || []);
flags2.aliases[key].concat(key).forEach(function(x6) {
if (/-/.test(x6) && configuration["camel-case-expansion"]) {
const c6 = camelCase(x6);
if (c6 !== key && flags2.aliases[key].indexOf(c6) === -1) {
flags2.aliases[key].push(c6);
newAliases[c6] = true;
}
}
});
flags2.aliases[key].concat(key).forEach(function(x6) {
if (x6.length > 1 && /[A-Z]/.test(x6) && configuration["camel-case-expansion"]) {
const c6 = decamelize(x6, "-");
if (c6 !== key && flags2.aliases[key].indexOf(c6) === -1) {
flags2.aliases[key].push(c6);
newAliases[c6] = true;
}
}
});
flags2.aliases[key].forEach(function(x6) {
flags2.aliases[x6] = [key].concat(flags2.aliases[key].filter(function(y4) {
return x6 !== y4;
}));
});
});
});
}
__name(extendAliases, "extendAliases");
function checkAllAliases(key, flag) {
const toCheck = [].concat(flags2.aliases[key] || [], key);
const keys = Object.keys(flag);
const setAlias = toCheck.find((key2) => keys.includes(key2));
return setAlias ? flag[setAlias] : false;
}
__name(checkAllAliases, "checkAllAliases");
function hasAnyFlag(key) {
const flagsKeys = Object.keys(flags2);
const toCheck = [].concat(flagsKeys.map((k6) => flags2[k6]));
return toCheck.some(function(flag) {
return Array.isArray(flag) ? flag.includes(key) : flag[key];
});
}
__name(hasAnyFlag, "hasAnyFlag");
function hasFlagsMatching(arg, ...patterns) {
const toCheck = [].concat(...patterns);
return toCheck.some(function(pattern) {
const match2 = arg.match(pattern);
return match2 && hasAnyFlag(match2[1]);
});
}
__name(hasFlagsMatching, "hasFlagsMatching");
function hasAllShortFlags(arg) {
if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
return false;
}
let hasAllFlags = true;
let next;
const letters = arg.slice(1).split("");
for (let j6 = 0; j6 < letters.length; j6++) {
next = arg.slice(j6 + 2);
if (!hasAnyFlag(letters[j6])) {
hasAllFlags = false;
break;
}
if (letters[j6 + 1] && letters[j6 + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j6]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j6 + 1] && letters[j6 + 1].match(/\W/)) {
break;
}
}
return hasAllFlags;
}
__name(hasAllShortFlags, "hasAllShortFlags");
function isUnknownOptionAsArg(arg) {
return configuration["unknown-options-as-args"] && isUnknownOption(arg);
}
__name(isUnknownOptionAsArg, "isUnknownOptionAsArg");
function isUnknownOption(arg) {
arg = arg.replace(/^-{3,}/, "--");
if (arg.match(negative)) {
return false;
}
if (hasAllShortFlags(arg)) {
return false;
}
const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
const normalFlag = /^-+([^=]+?)$/;
const flagEndingInHyphen = /^-+([^=]+?)-$/;
const flagEndingInDigits = /^-+([^=]+?\d+)$/;
const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
}
__name(isUnknownOption, "isUnknownOption");
function defaultValue(key) {
if (!checkAllAliases(key, flags2.bools) && !checkAllAliases(key, flags2.counts) && `${key}` in defaults) {
return defaults[key];
} else {
return defaultForType(guessType2(key));
}
}
__name(defaultValue, "defaultValue");
function defaultForType(type) {
const def = {
[DefaultValuesForTypeKey.BOOLEAN]: true,
[DefaultValuesForTypeKey.STRING]: "",
[DefaultValuesForTypeKey.NUMBER]: void 0,
[DefaultValuesForTypeKey.ARRAY]: []
};
return def[type];
}
__name(defaultForType, "defaultForType");
function guessType2(key) {
let type = DefaultValuesForTypeKey.BOOLEAN;
if (checkAllAliases(key, flags2.strings))
type = DefaultValuesForTypeKey.STRING;
else if (checkAllAliases(key, flags2.numbers))
type = DefaultValuesForTypeKey.NUMBER;
else if (checkAllAliases(key, flags2.bools))
type = DefaultValuesForTypeKey.BOOLEAN;
else if (checkAllAliases(key, flags2.arrays))
type = DefaultValuesForTypeKey.ARRAY;
return type;
}
__name(guessType2, "guessType");
function isUndefined(num) {
return num === void 0;
}
__name(isUndefined, "isUndefined");
function checkConfiguration() {
Object.keys(flags2.counts).find((key) => {
if (checkAllAliases(key, flags2.arrays)) {
error2 = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
return true;
} else if (checkAllAliases(key, flags2.nargs)) {
error2 = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
return true;
}
return false;
});
}
__name(checkConfiguration, "checkConfiguration");
return {
aliases: Object.assign({}, flags2.aliases),
argv: Object.assign(argvReturn, argv),
configuration,
defaulted: Object.assign({}, defaulted),
error: error2,
newAliases: Object.assign({}, newAliases)
};
}
};
__name(combineAliases, "combineAliases");
__name(increment, "increment");
__name(sanitizeKey, "sanitizeKey");
__name(stripQuotes, "stripQuotes");
}
});
// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/index.js
var import_util, import_path, import_fs, _a, _b, _c, minNodeVersion, nodeVersion, env, parser, yargsParser, lib_default;
var init_lib = __esm({
"../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/index.js"() {
init_import_meta_url();
import_util = require("util");
import_path = require("path");
init_string_utils();
init_yargs_parser();
import_fs = require("fs");
minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 12;
nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
if (nodeVersion) {
const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
if (major < minNodeVersion) {
throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
}
}
env = process ? process.env : {};
parser = new YargsParser({
cwd: process.cwd,
env: /* @__PURE__ */ __name(() => {
return env;
}, "env"),
format: import_util.format,
normalize: import_path.normalize,
resolve: import_path.resolve,
// TODO: figure out a way to combine ESM and CJS coverage, such that
// we can exercise all the lines below:
require: /* @__PURE__ */ __name((path71) => {
if (typeof require !== "undefined") {
return require(path71);
} else if (path71.match(/\.json$/)) {
return JSON.parse((0, import_fs.readFileSync)(path71, "utf8"));
} else {
throw Error("only .json config files are supported in ESM");
}
}, "require")
});
yargsParser = /* @__PURE__ */ __name(function Parser(args, opts) {
const result = parser.parse(args.slice(), opts);
return result.argv;
}, "Parser");
yargsParser.detailed = function(args, opts) {
return parser.parse(args.slice(), opts);
};
yargsParser.camelCase = camelCase;
yargsParser.decamelize = decamelize;
yargsParser.looksLikeNumber = looksLikeNumber;
lib_default = yargsParser;
}
});
// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/build/lib/index.js
function addBorder(col, ts, style) {
if (col.border) {
if (/[.']-+[.']/.test(ts)) {
return "";
}
if (ts.trim().length !== 0) {
return style;
}
return " ";
}
return "";
}
function _minWidth(col) {
const padding = col.padding || [];
const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
if (col.border) {
return minWidth + 4;
}
return minWidth;
}
function getWindowWidth() {
if (typeof process === "object" && process.stdout && process.stdout.columns) {
return process.stdout.columns;
}
return 80;
}
function alignRight(str, width) {
str = str.trim();
const strWidth = mixin2.stringWidth(str);
if (strWidth < width) {
return " ".repeat(width - strWidth) + str;
}
return str;
}
function alignCenter(str, width) {
str = str.trim();
const strWidth = mixin2.stringWidth(str);
if (strWidth >= width) {
return str;
}
return " ".repeat(width - strWidth >> 1) + str;
}
function cliui(opts, _mixin) {
mixin2 = _mixin;
return new UI({
width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(),
wrap: opts === null || opts === void 0 ? void 0 : opts.wrap
});
}
var align, top, right, bottom, left, UI, mixin2;
var init_lib2 = __esm({
"../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/build/lib/index.js"() {
"use strict";
init_import_meta_url();
align = {
right: alignRight,
center: alignCenter
};
top = 0;
right