@zkochan/pnpm
Version:
1,409 lines (1,386 loc) • 490 kB
JavaScript
var __commonJS = (cb, mod) => () => (mod || cb((mod = {exports: {}}).exports, mod), mod.exports);
// ../error/lib/index.js
var require_lib = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.FetchError = void 0;
var PnpmError = class extends Error {
constructor(code, message, opts) {
super(message);
this.code = `ERR_PNPM_${code}`;
this.hint = opts === null || opts === void 0 ? void 0 : opts.hint;
this.attempts = opts === null || opts === void 0 ? void 0 : opts.attempts;
}
};
exports2.default = PnpmError;
var FetchError = class extends PnpmError {
constructor(request, response, hint) {
const message = `GET ${request.url}: ${response.statusText} - ${response.status}`;
const authHeaderValue = request.authHeaderValue ? hideAuthInformation(request.authHeaderValue) : void 0;
if (response.status === 401 || response.status === 403 || response.status === 404) {
hint = hint ? `${hint}
` : "";
if (authHeaderValue) {
hint += `An authorization header was used: ${authHeaderValue}`;
} else {
hint += "No authorization header was set for the request.";
}
}
super(`FETCH_${response.status}`, message, {hint});
this.request = request;
this.response = response;
}
};
exports2.FetchError = FetchError;
function hideAuthInformation(authHeaderValue) {
const [authType, token] = authHeaderValue.split(" ");
return `${authType} ${token.substring(0, 4)}[hidden]`;
}
});
// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
var require_yocto_queue = __commonJS((exports2, module2) => {
var Node = class {
constructor(value) {
this.value = value;
this.next = void 0;
}
};
var Queue = class {
constructor() {
this.clear();
}
enqueue(value) {
const node = new Node(value);
if (this._head) {
this._tail.next = node;
this._tail = node;
} else {
this._head = node;
this._tail = node;
}
this._size++;
}
dequeue() {
const current = this._head;
if (!current) {
return;
}
this._head = this._head.next;
this._size--;
return current.value;
}
clear() {
this._head = void 0;
this._tail = void 0;
this._size = 0;
}
get size() {
return this._size;
}
*[Symbol.iterator]() {
let current = this._head;
while (current) {
yield current.value;
current = current.next;
}
}
};
module2.exports = Queue;
});
// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
var require_p_limit = __commonJS((exports2, module2) => {
"use strict";
var Queue = require_yocto_queue();
var pLimit = (concurrency) => {
if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
throw new TypeError("Expected `concurrency` to be a number from 1 and up");
}
const queue = new Queue();
let activeCount = 0;
const next = () => {
activeCount--;
if (queue.size > 0) {
queue.dequeue()();
}
};
const run = async (fn, resolve, ...args) => {
activeCount++;
const result = (async () => fn(...args))();
resolve(result);
try {
await result;
} catch {
}
next();
};
const enqueue = (fn, resolve, ...args) => {
queue.enqueue(run.bind(null, fn, resolve, ...args));
(async () => {
await Promise.resolve();
if (activeCount < concurrency && queue.size > 0) {
queue.dequeue()();
}
})();
};
const generator = (fn, ...args) => new Promise((resolve) => {
enqueue(fn, resolve, ...args);
});
Object.defineProperties(generator, {
activeCount: {
get: () => activeCount
},
pendingCount: {
get: () => queue.size
},
clearQueue: {
value: () => {
queue.clear();
}
}
});
return generator;
};
module2.exports = pLimit;
});
// ../../node_modules/.pnpm/p-locate@5.0.0/node_modules/p-locate/index.js
var require_p_locate = __commonJS((exports2, module2) => {
"use strict";
var pLimit = require_p_limit();
var EndError = class extends Error {
constructor(value) {
super();
this.value = value;
}
};
var testElement = async (element, tester) => tester(await element);
var finder = async (element) => {
const values = await Promise.all(element);
if (values[1] === true) {
throw new EndError(values[0]);
}
return false;
};
var pLocate = async (iterable, tester, options) => {
options = {
concurrency: Infinity,
preserveOrder: true,
...options
};
const limit = pLimit(options.concurrency);
const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
try {
await Promise.all(items.map((element) => checkLimit(finder, element)));
} catch (error) {
if (error instanceof EndError) {
return error.value;
}
throw error;
}
};
module2.exports = pLocate;
});
// ../../node_modules/.pnpm/locate-path@6.0.0/node_modules/locate-path/index.js
var require_locate_path = __commonJS((exports2, module2) => {
"use strict";
var path = require("path");
var fs = require("fs");
var {promisify} = require("util");
var pLocate = require_p_locate();
var fsStat = promisify(fs.stat);
var fsLStat = promisify(fs.lstat);
var typeMappings = {
directory: "isDirectory",
file: "isFile"
};
function checkType({type}) {
if (type in typeMappings) {
return;
}
throw new Error(`Invalid type specified: ${type}`);
}
var matchType = (type, stat) => type === void 0 || stat[typeMappings[type]]();
module2.exports = async (paths, options) => {
options = {
cwd: process.cwd(),
type: "file",
allowSymlinks: true,
...options
};
checkType(options);
const statFn = options.allowSymlinks ? fsStat : fsLStat;
return pLocate(paths, async (path_) => {
try {
const stat = await statFn(path.resolve(options.cwd, path_));
return matchType(options.type, stat);
} catch {
return false;
}
}, options);
};
module2.exports.sync = (paths, options) => {
options = {
cwd: process.cwd(),
allowSymlinks: true,
type: "file",
...options
};
checkType(options);
const statFn = options.allowSymlinks ? fs.statSync : fs.lstatSync;
for (const path_ of paths) {
try {
const stat = statFn(path.resolve(options.cwd, path_));
if (matchType(options.type, stat)) {
return path_;
}
} catch {
}
}
};
});
// ../../node_modules/.pnpm/path-exists@4.0.0/node_modules/path-exists/index.js
var require_path_exists = __commonJS((exports2, module2) => {
"use strict";
var fs = require("fs");
var {promisify} = require("util");
var pAccess = promisify(fs.access);
module2.exports = async (path) => {
try {
await pAccess(path);
return true;
} catch (_) {
return false;
}
};
module2.exports.sync = (path) => {
try {
fs.accessSync(path);
return true;
} catch (_) {
return false;
}
};
});
// ../../node_modules/.pnpm/find-up@5.0.0/node_modules/find-up/index.js
var require_find_up = __commonJS((exports2, module2) => {
"use strict";
var path = require("path");
var locatePath = require_locate_path();
var pathExists = require_path_exists();
var stop = Symbol("findUp.stop");
module2.exports = async (name, options = {}) => {
let directory = path.resolve(options.cwd || "");
const {root} = path.parse(directory);
const paths = [].concat(name);
const runMatcher = async (locateOptions) => {
if (typeof name !== "function") {
return locatePath(paths, locateOptions);
}
const foundPath = await name(locateOptions.cwd);
if (typeof foundPath === "string") {
return locatePath([foundPath], locateOptions);
}
return foundPath;
};
while (true) {
const foundPath = await runMatcher({...options, cwd: directory});
if (foundPath === stop) {
return;
}
if (foundPath) {
return path.resolve(directory, foundPath);
}
if (directory === root) {
return;
}
directory = path.dirname(directory);
}
};
module2.exports.sync = (name, options = {}) => {
let directory = path.resolve(options.cwd || "");
const {root} = path.parse(directory);
const paths = [].concat(name);
const runMatcher = (locateOptions) => {
if (typeof name !== "function") {
return locatePath.sync(paths, locateOptions);
}
const foundPath = name(locateOptions.cwd);
if (typeof foundPath === "string") {
return locatePath.sync([foundPath], locateOptions);
}
return foundPath;
};
while (true) {
const foundPath = runMatcher({...options, cwd: directory});
if (foundPath === stop) {
return;
}
if (foundPath) {
return path.resolve(directory, foundPath);
}
if (directory === root) {
return;
}
directory = path.dirname(directory);
}
};
module2.exports.exists = pathExists;
module2.exports.sync.exists = pathExists.sync;
module2.exports.stop = stop;
});
// ../find-workspace-dir/lib/index.js
var require_lib2 = __commonJS((exports2) => {
"use strict";
var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : {default: mod};
};
Object.defineProperty(exports2, "__esModule", {value: true});
var path_12 = __importDefault2(require("path"));
var error_1 = __importDefault2(require_lib());
var find_up_1 = __importDefault2(require_find_up());
var WORKSPACE_MANIFEST_FILENAME = "pnpm-workspace.yaml";
async function findWorkspaceDir(cwd) {
const workspaceManifestLocation = await (0, find_up_1.default)([WORKSPACE_MANIFEST_FILENAME, "pnpm-workspace.yml"], {cwd});
if (workspaceManifestLocation === null || workspaceManifestLocation === void 0 ? void 0 : workspaceManifestLocation.endsWith(".yml")) {
throw new error_1.default("BAD_WORKSPACE_MANIFEST_NAME", `The workspace manifest file should be named "pnpm-workspace.yaml". File found: ${workspaceManifestLocation}`);
}
return workspaceManifestLocation && path_12.default.dirname(workspaceManifestLocation);
}
exports2.default = findWorkspaceDir;
});
// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
var require_safe_buffer = __commonJS((exports2, module2) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require("buffer");
var Buffer2 = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) {
dst[key] = src[key];
}
}
if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
module2.exports = buffer;
} else {
copyProps(buffer, exports2);
exports2.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer2(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer2.prototype);
copyProps(Buffer2, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
throw new TypeError("Argument must not be a number");
}
return Buffer2(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
var buf = Buffer2(size);
if (fill !== void 0) {
if (typeof encoding === "string") {
buf.fill(fill, encoding);
} else {
buf.fill(fill);
}
} else {
buf.fill(0);
}
return buf;
};
SafeBuffer.allocUnsafe = function(size) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
return Buffer2(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
return buffer.SlowBuffer(size);
};
});
// ../../node_modules/.pnpm/@zkochan+libnpx@13.1.2/node_modules/@zkochan/libnpx/util.js
var require_util = __commonJS((exports2, module2) => {
"use strict";
module2.exports.promisify = promisify;
function promisify(f) {
const util = require("util");
if (util.promisify) {
return util.promisify(f);
} else {
return function() {
return new Promise((resolve, reject) => {
f.apply(this, [].slice.call(arguments).concat((err, val) => {
err ? reject(err) : resolve(val);
}));
});
};
}
}
});
// ../../node_modules/.pnpm/yargs@15.4.1/node_modules/yargs/build/lib/common-types.js
var require_common_types = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.objectKeys = exports2.assertSingleKey = exports2.assertNotStrictEqual = void 0;
var assert_1 = require("assert");
function assertNotStrictEqual(actual, expected, message) {
assert_1.notStrictEqual(actual, expected, message);
}
exports2.assertNotStrictEqual = assertNotStrictEqual;
function assertSingleKey(actual) {
assert_1.strictEqual(typeof actual, "string");
}
exports2.assertSingleKey = assertSingleKey;
function objectKeys(object) {
return Object.keys(object);
}
exports2.objectKeys = objectKeys;
});
// ../../node_modules/.pnpm/yargs@15.4.1/node_modules/yargs/build/lib/is-promise.js
var require_is_promise = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.isPromise = void 0;
function isPromise(maybePromise) {
return !!maybePromise && !!maybePromise.then && typeof maybePromise.then === "function";
}
exports2.isPromise = isPromise;
});
// ../../node_modules/.pnpm/yargs@15.4.1/node_modules/yargs/build/lib/yerror.js
var require_yerror = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.YError = void 0;
var YError = class extends Error {
constructor(msg) {
super(msg || "yargs error");
this.name = "YError";
Error.captureStackTrace(this, YError);
}
};
exports2.YError = YError;
});
// ../../node_modules/.pnpm/yargs@15.4.1/node_modules/yargs/build/lib/parse-command.js
var require_parse_command = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.parseCommand = void 0;
function parseCommand(cmd) {
const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, " ");
const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
const bregex = /\.*[\][<>]/g;
const firstCommand = splitCommand.shift();
if (!firstCommand)
throw new Error(`No command found in: ${cmd}`);
const parsedCommand = {
cmd: firstCommand.replace(bregex, ""),
demanded: [],
optional: []
};
splitCommand.forEach((cmd2, i) => {
let variadic = false;
cmd2 = cmd2.replace(/\s/g, "");
if (/\.+[\]>]/.test(cmd2) && i === splitCommand.length - 1)
variadic = true;
if (/^\[/.test(cmd2)) {
parsedCommand.optional.push({
cmd: cmd2.replace(bregex, "").split("|"),
variadic
});
} else {
parsedCommand.demanded.push({
cmd: cmd2.replace(bregex, "").split("|"),
variadic
});
}
});
return parsedCommand;
}
exports2.parseCommand = parseCommand;
});
// ../../node_modules/.pnpm/yargs@15.4.1/node_modules/yargs/build/lib/argsert.js
var require_argsert = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.argsert = void 0;
var yerror_1 = require_yerror();
var parse_command_1 = require_parse_command();
var positionName = ["first", "second", "third", "fourth", "fifth", "sixth"];
function argsert(arg1, arg2, arg3) {
function parseArgs() {
return typeof arg1 === "object" ? [{demanded: [], optional: []}, arg1, arg2] : [parse_command_1.parseCommand(`cmd ${arg1}`), arg2, arg3];
}
try {
let position = 0;
let [parsed, callerArguments, length] = parseArgs();
const args = [].slice.call(callerArguments);
while (args.length && args[args.length - 1] === void 0)
args.pop();
length = length || args.length;
if (length < parsed.demanded.length) {
throw new yerror_1.YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
}
const totalCommands = parsed.demanded.length + parsed.optional.length;
if (length > totalCommands) {
throw new yerror_1.YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
}
parsed.demanded.forEach((demanded) => {
const arg = args.shift();
const observedType = guessType(arg);
const matchingTypes = demanded.cmd.filter((type) => type === observedType || type === "*");
if (matchingTypes.length === 0)
argumentTypeError(observedType, demanded.cmd, position);
position += 1;
});
parsed.optional.forEach((optional) => {
if (args.length === 0)
return;
const arg = args.shift();
const observedType = guessType(arg);
const matchingTypes = optional.cmd.filter((type) => type === observedType || type === "*");
if (matchingTypes.length === 0)
argumentTypeError(observedType, optional.cmd, position);
position += 1;
});
} catch (err) {
console.warn(err.stack);
}
}
exports2.argsert = argsert;
function guessType(arg) {
if (Array.isArray(arg)) {
return "array";
} else if (arg === null) {
return "null";
}
return typeof arg;
}
function argumentTypeError(observedType, allowedTypes, position) {
throw new yerror_1.YError(`Invalid ${positionName[position] || "manyith"} argument. Expected ${allowedTypes.join(" or ")} but received ${observedType}.`);
}
});
// ../../node_modules/.pnpm/yargs@15.4.1/node_modules/yargs/build/lib/middleware.js
var require_middleware = __commonJS((exports2) => {
"use strict";
Object.defineProperty(exports2, "__esModule", {value: true});
exports2.applyMiddleware = exports2.commandMiddlewareFactory = exports2.globalMiddlewareFactory = void 0;
var argsert_1 = require_argsert();
var is_promise_1 = require_is_promise();
function globalMiddlewareFactory(globalMiddleware, context) {
return function(callback, applyBeforeValidation = false) {
argsert_1.argsert("<array|function> [boolean]", [callback, applyBeforeValidation], arguments.length);
if (Array.isArray(callback)) {
for (let i = 0; i < callback.length; i++) {
if (typeof callback[i] !== "function") {
throw Error("middleware must be a function");
}
callback[i].applyBeforeValidation = applyBeforeValidation;
}
Array.prototype.push.apply(globalMiddleware, callback);
} else if (typeof callback === "function") {
callback.applyBeforeValidation = applyBeforeValidation;
globalMiddleware.push(callback);
}
return context;
};
}
exports2.globalMiddlewareFactory = globalMiddlewareFactory;
function commandMiddlewareFactory(commandMiddleware) {
if (!commandMiddleware)
return [];
return commandMiddleware.map((middleware) => {
middleware.applyBeforeValidation = false;
return middleware;
});
}
exports2.commandMiddlewareFactory = commandMiddlewareFactory;
function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
const beforeValidationError = new Error("middleware cannot return a promise when applyBeforeValidation is true");
return middlewares.reduce((acc, middleware) => {
if (middleware.applyBeforeValidation !== beforeValidation) {
return acc;
}
if (is_promise_1.isPromise(acc)) {
return acc.then((initialObj) => Promise.all([initialObj, middleware(initialObj, yargs)])).then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
} else {
const result = middleware(acc, yargs);
if (beforeValidation && is_promise_1.isPromise(result))
throw beforeValidationError;
return is_promise_1.isPromise(result) ? result.then((middlewareObj) => Object.assign(acc, middlewareObj)) : Object.assign(acc, result);
}
}, argv);
}
exports2.applyMiddleware = applyMiddleware;
});
// ../../node_modules/.pnpm/require-directory@2.1.1/node_modules/require-directory/index.js
var require_require_directory = __commonJS((exports2, module2) => {
"use strict";
var fs = require("fs");
var join = require("path").join;
var resolve = require("path").resolve;
var dirname = require("path").dirname;
var defaultOptions = {
extensions: ["js", "json", "coffee"],
recurse: true,
rename: function(name) {
return name;
},
visit: function(obj) {
return obj;
}
};
function checkFileInclusion(path, filename, options) {
return new RegExp("\\.(" + options.extensions.join("|") + ")$", "i").test(filename) && !(options.include && options.include instanceof RegExp && !options.include.test(path)) && !(options.include && typeof options.include === "function" && !options.include(path, filename)) && !(options.exclude && options.exclude instanceof RegExp && options.exclude.test(path)) && !(options.exclude && typeof options.exclude === "function" && options.exclude(path, filename));
}
function requireDirectory(m, path, options) {
var retval = {};
if (path && !options && typeof path !== "string") {
options = path;
path = null;
}
options = options || {};
for (var prop in defaultOptions) {
if (typeof options[prop] === "undefined") {
options[prop] = defaultOptions[prop];
}
}
path = !path ? dirname(m.filename) : resolve(dirname(m.filename), path);
fs.readdirSync(path).forEach(function(filename) {
var joined = join(path, filename), files, key, obj;
if (fs.statSync(joined).isDirectory() && options.recurse) {
files = requireDirectory(m, joined, options);
if (Object.keys(files).length) {
retval[options.rename(filename, joined, filename)] = files;
}
} else {
if (joined !== m.filename && checkFileInclusion(joined, filename, options)) {
key = filename.substring(0, filename.lastIndexOf("."));
obj = m.require(joined);
retval[options.rename(key, joined, filename)] = options.visit(obj, joined, filename) || obj;
}
}
});
return retval;
}
module2.exports = requireDirectory;
module2.exports.defaults = defaultOptions;
});
// ../../node_modules/.pnpm/which-module@2.0.0/node_modules/which-module/index.js
var require_which_module = __commonJS((exports2, module2) => {
"use strict";
module2.exports = function whichModule(exported) {
for (var i = 0, files = Object.keys(require.cache), mod; i < files.length; i++) {
mod = require.cache[files[i]];
if (mod.exports === exported)
return mod;
}
return null;
};
});
// ../../node_modules/.pnpm/camelcase@5.3.1/node_modules/camelcase/index.js
var require_camelcase = __commonJS((exports2, module2) => {
"use strict";
var preserveCamelCase = (string) => {
let isLastCharLower = false;
let isLastCharUpper = false;
let isLastLastCharUpper = false;
for (let i = 0; i < string.length; i++) {
const character = string[i];
if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
string = string.slice(0, i) + "-" + string.slice(i);
isLastCharLower = false;
isLastLastCharUpper = isLastCharUpper;
isLastCharUpper = true;
i++;
} else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(character) && character.toLowerCase() === character) {
string = string.slice(0, i - 1) + "-" + string.slice(i - 1);
isLastLastCharUpper = isLastCharUpper;
isLastCharUpper = false;
isLastCharLower = true;
} else {
isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
isLastLastCharUpper = isLastCharUpper;
isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
}
}
return string;
};
var camelCase = (input, options) => {
if (!(typeof input === "string" || Array.isArray(input))) {
throw new TypeError("Expected the input to be `string | string[]`");
}
options = Object.assign({
pascalCase: false
}, options);
const postProcess = (x) => options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x;
if (Array.isArray(input)) {
input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
} else {
input = input.trim();
}
if (input.length === 0) {
return "";
}
if (input.length === 1) {
return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
}
const hasUpperCase = input !== input.toLowerCase();
if (hasUpperCase) {
input = preserveCamelCase(input);
}
input = input.replace(/^[_.\- ]+/, "").toLowerCase().replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase()).replace(/\d+(\w|$)/g, (m) => m.toUpperCase());
return postProcess(input);
};
module2.exports = camelCase;
module2.exports.default = camelCase;
});
// ../../node_modules/.pnpm/decamelize@1.2.0/node_modules/decamelize/index.js
var require_decamelize = __commonJS((exports2, module2) => {
"use strict";
module2.exports = function(str, sep) {
if (typeof str !== "string") {
throw new TypeError("Expected a string");
}
sep = typeof sep === "undefined" ? "_" : sep;
return str.replace(/([a-z\d])([A-Z])/g, "$1" + sep + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + sep + "$2").toLowerCase();
};
});
// ../../node_modules/.pnpm/yargs-parser@18.1.3/node_modules/yargs-parser/lib/tokenize-arg-string.js
var require_tokenize_arg_string = __commonJS((exports2, module2) => {
module2.exports = function(argString) {
if (Array.isArray(argString)) {
return argString.map((e) => typeof e !== "string" ? e + "" : e);
}
argString = argString.trim();
let i = 0;
let prevC = null;
let c = null;
let opening = null;
const args = [];
for (let ii = 0; ii < argString.length; ii++) {
prevC = c;
c = argString.charAt(ii);
if (c === " " && !opening) {
if (!(prevC === " ")) {
i++;
}
continue;
}
if (c === opening) {
opening = null;
} else if ((c === "'" || c === '"') && !opening) {
opening = c;
}
if (!args[i])
args[i] = "";
args[i] += c;
}
return args;
};
});
// ../../node_modules/.pnpm/yargs-parser@18.1.3/node_modules/yargs-parser/index.js
var require_yargs_parser = __commonJS((exports2, module2) => {
var camelCase = require_camelcase();
var decamelize = require_decamelize();
var path = require("path");
var tokenizeArgString = require_tokenize_arg_string();
var util = require("util");
function parse(args, opts) {
opts = Object.assign(Object.create(null), opts);
args = tokenizeArgString(args);
const aliases = combineAliases(Object.assign(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,
"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(Object.create(null), opts.default);
const configObjects = opts.configObjects || [];
const envPrefix = opts.envPrefix;
const notFlagsOption = configuration["populate--"];
const notFlagsArgv = notFlagsOption ? "--" : "_";
const newAliases = Object.create(null);
const defaulted = Object.create(null);
const __ = opts.__ || util.format;
const flags = {
aliases: Object.create(null),
arrays: Object.create(null),
bools: Object.create(null),
strings: Object.create(null),
numbers: Object.create(null),
counts: Object.create(null),
normalize: Object.create(null),
configs: Object.create(null),
nargs: Object.create(null),
coercions: 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 = opt.key || opt;
const assignment = Object.keys(opt).map(function(key2) {
return {
boolean: "bools",
string: "strings",
number: "numbers"
}[key2];
}).filter(Boolean).pop();
if (assignment) {
flags[assignment][key] = true;
}
flags.arrays[key] = true;
flags.keys.push(key);
});
[].concat(opts.boolean).filter(Boolean).forEach(function(key) {
flags.bools[key] = true;
flags.keys.push(key);
});
[].concat(opts.string).filter(Boolean).forEach(function(key) {
flags.strings[key] = true;
flags.keys.push(key);
});
[].concat(opts.number).filter(Boolean).forEach(function(key) {
flags.numbers[key] = true;
flags.keys.push(key);
});
[].concat(opts.count).filter(Boolean).forEach(function(key) {
flags.counts[key] = true;
flags.keys.push(key);
});
[].concat(opts.normalize).filter(Boolean).forEach(function(key) {
flags.normalize[key] = true;
flags.keys.push(key);
});
Object.keys(opts.narg || {}).forEach(function(k) {
flags.nargs[k] = opts.narg[k];
flags.keys.push(k);
});
Object.keys(opts.coerce || {}).forEach(function(k) {
flags.coercions[k] = opts.coerce[k];
flags.keys.push(k);
});
if (Array.isArray(opts.config) || typeof opts.config === "string") {
;
[].concat(opts.config).filter(Boolean).forEach(function(key) {
flags.configs[key] = true;
});
} else {
Object.keys(opts.config || {}).forEach(function(k) {
flags.configs[k] = opts.config[k];
});
}
extendAliases(opts.key, aliases, opts.default, flags.arrays);
Object.keys(defaults).forEach(function(key) {
(flags.aliases[key] || []).forEach(function(alias) {
defaults[alias] = defaults[key];
});
});
let error = null;
checkConfiguration();
let notFlags = [];
const argv = Object.assign(Object.create(null), {_: []});
const argvReturn = {};
for (let i = 0; i < args.length; i++) {
const arg = args[i];
let broken;
let key;
let letters;
let m;
let next;
let value;
if (arg !== "--" && isUnknownOptionAsArg(arg)) {
argv._.push(arg);
} else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
if (checkAllAliases(m[1], flags.arrays)) {
i = eatArray(i, m[1], args, m[2]);
} else if (checkAllAliases(m[1], flags.nargs) !== false) {
i = eatNargs(i, m[1], args, m[2]);
} else {
setArg(m[1], m[2]);
}
} else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
key = arg.match(negatedBoolean)[1];
setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
} else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
key = arg.match(/^--?(.+)/)[1];
if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args);
} else if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args);
} else {
next = args[i + 1];
if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
setArg(key, next);
i++;
} else if (/^(true|false)$/.test(next)) {
setArg(key, next);
i++;
} else {
setArg(key, defaultValue(key));
}
}
} else if (arg.match(/^-.\..+=/)) {
m = arg.match(/^-([^=]+)=([\s\S]*)$/);
setArg(m[1], m[2]);
} else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
next = args[i + 1];
key = arg.match(/^-(.\..+)/)[1];
if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
setArg(key, next);
i++;
} else {
setArg(key, defaultValue(key));
}
} else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
letters = arg.slice(1, -1).split("");
broken = false;
for (let j = 0; j < letters.length; j++) {
next = arg.slice(j + 2);
if (letters[j + 1] && letters[j + 1] === "=") {
value = arg.slice(j + 3);
key = letters[j];
if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args, value);
} else if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args, value);
} else {
setArg(key, value);
}
broken = true;
break;
}
if (next === "-") {
setArg(letters[j], next);
continue;
}
if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
setArg(letters[j], next);
broken = true;
break;
}
if (letters[j + 1] && letters[j + 1].match(/\W/)) {
setArg(letters[j], next);
broken = true;
break;
} else {
setArg(letters[j], defaultValue(letters[j]));
}
}
key = arg.slice(-1)[0];
if (!broken && key !== "-") {
if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args);
} else if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args);
} else {
next = args[i + 1];
if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
setArg(key, next);
i++;
} else if (/^(true|false)$/.test(next)) {
setArg(key, next);
i++;
} else {
setArg(key, defaultValue(key));
}
}
}
} else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
key = arg.slice(1);
setArg(key, defaultValue(key));
} else if (arg === "--") {
notFlags = args.slice(i + 1);
break;
} else if (configuration["halt-at-non-option"]) {
notFlags = args.slice(i);
break;
} else {
argv._.push(maybeCoerceNumber("_", arg));
}
}
applyEnvVars(argv, true);
applyEnvVars(argv, false);
setConfig(argv);
setConfigObjects();
applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
applyCoercions(argv);
if (configuration["set-placeholder-key"])
setPlaceholderKeys(argv);
Object.keys(flags.counts).forEach(function(key) {
if (!hasKey(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(aliases).map((k) => aliases[k])).forEach((alias) => {
if (configuration["camel-case-expansion"]) {
delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
}
delete argv[alias];
});
}
function eatNargs(i, key, args2, argAfterEqualSign) {
let ii;
let toEat = checkAllAliases(key, flags.nargs);
toEat = isNaN(toEat) ? 1 : toEat;
if (toEat === 0) {
if (!isUndefined(argAfterEqualSign)) {
error = Error(__("Argument unexpected for: %s", key));
}
setArg(key, defaultValue(key));
return i;
}
let available = isUndefined(argAfterEqualSign) ? 0 : 1;
if (configuration["nargs-eats-options"]) {
if (args2.length - (i + 1) + available < toEat) {
error = Error(__("Not enough arguments following: %s", key));
}
available = toEat;
} else {
for (ii = i + 1; ii < args2.length; ii++) {
if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii]))
available++;
else
break;
}
if (available < toEat)
error = Error(__("Not enough arguments following: %s", key));
}
let consumed = Math.min(available, toEat);
if (!isUndefined(argAfterEqualSign) && consumed > 0) {
setArg(key, argAfterEqualSign);
consumed--;
}
for (ii = i + 1; ii < consumed + i + 1; ii++) {
setArg(key, args2[ii]);
}
return i + consumed;
}
function eatArray(i, key, args2, argAfterEqualSign) {
let argsToSet = [];
let next = argAfterEqualSign || args2[i + 1];
const nargsCount = checkAllAliases(key, flags.nargs);
if (checkAllAliases(key, flags.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));
}
for (let ii = i + 1; ii < args2.length; ii++) {
if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && argsToSet.length >= nargsCount)
break;
next = args2[ii];
if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
break;
i = ii;
argsToSet.push(processValue(key, next));
}
}
if (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0) {
error = Error(__("Not enough arguments following: %s", key));
}
setArg(key, argsToSet);
return i;
}
function setArg(key, val) {
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, val);
const splitKey = key.split(".");
setKey(argv, splitKey, value);
if (flags.aliases[key]) {
flags.aliases[key].forEach(function(x) {
x = x.split(".");
setKey(argv, x, value);
});
}
if (splitKey.length > 1 && configuration["dot-notation"]) {
;
(flags.aliases[splitKey[0]] || []).forEach(function(x) {
x = x.split(".");
const a = [].concat(splitKey);
a.shift();
x = x.concat(a);
if (!(flags.aliases[key] || []).includes(x.join("."))) {
setKey(argv, x, value);
}
});
}
if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
const keys = [key].concat(flags.aliases[key] || []);
keys.forEach(function(key2) {
Object.defineProperty(argvReturn, key2, {
enumerable: true,
get() {
return val;
},
set(value2) {
val = typeof value2 === "string" ? path.normalize(value2) : value2;
}
});
});
}
}
function addNewAlias(key, alias) {
if (!(flags.aliases[key] && flags.aliases[key].length)) {
flags.aliases[key] = [alias];
newAliases[alias] = true;
}
if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
addNewAlias(alias, key);
}
}
function processValue(key, val) {
if (typeof val === "string" && (val[0] === "'" || val[0] === '"') && val[val.length - 1] === val[0]) {
val = val.substring(1, val.length - 1);
}
if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
if (typeof val === "string")
val = val === "true";
}
let value = Array.isArray(val) ? val.map(function(v) {
return maybeCoerceNumber(key, v);
}) : maybeCoerceNumber(key, val);
if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) {
value = increment;
}
if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
if (Array.isArray(val))
value = val.map(path.normalize);
else
value = path.normalize(val);
}
return value;
}
function maybeCoerceNumber(key, value) {
if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
const shouldCoerceNumber = isNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(value));
if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers))
value = Number(value);
}
return value;
}
function setConfig(argv2) {
const configLookup = Object.create(null);
applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
Object.keys(flags.configs).forEach(function(configKey) {
const configPath = argv2[configKey] || configLookup[configKey];
if (configPath) {
try {
let config = null;
const resolvedConfigPath = path.resolve(process.cwd(), configPath);
if (typeof flags.configs[configKey] === "function") {
try {
config = flags.configs[configKey](resolvedConfigPath);
} catch (e) {
config = e;
}
if (config instanceof Error) {
error = config;
return;
}
} else {
config = require(resolvedConfigPath);
}
setConfigObject(config);
} catch (ex) {
if (argv2[configKey])
error = Error(__("Invalid JSON config file: %s", configPath));
}
}
});
}
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 (!hasKey(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) {
setArg(fullKey, value);
}
}
});
}
function setConfigObjects() {
if (typeof configObjects === "undefined")
return;
configObjects.forEach(function(configObject) {
setConfigObject(configObject);
});
}
function applyEnvVars(argv2, configOnly) {
if (typeof envPrefix === "undefined")
return;
const prefix = typeof envPrefix === "string" ? envPrefix : "";
Object.keys(process.env).forEach(function(envVar) {
if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
const keys = envVar.split("__").map(function(key, i) {
if (i === 0) {
key = key.substring(prefix.length);
}
return camelCase(key);
});
if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey(argv2, keys)) {
setArg(keys.join("."), process.env[envVar]);
}
}
});
}
function applyCoercions(argv2) {
let coerce;
const applied = new Set();
Object.keys(argv2).forEach(function(key) {
if (!applied.has(key)) {
coerce = checkAllAliases(key, flags.coercions);
if (typeof coerce === "function") {
try {
const value = maybeCoerceNumber(key, coerce(argv2[key]));
[].concat(flags.aliases[key] || [], key).forEach((ali) => {
applied.add(ali);
argv2[ali] = value;
});
} catch (err) {
error = err;
}
}
}
});
}
function setPlaceholderKeys(argv2) {
flags.keys.forEach((key) => {
if (~key.indexOf("."))
return;
if (typeof argv2[key] === "undefined")
argv2[key] = void 0;
});
return argv2;
}
function applyDefaultsAndAliases(obj, aliases2, defaults2, canLog = false) {
Object.keys(defaults2).forEach(function(key) {
if (!hasKey(obj, key.split("."))) {
setKey(obj, key.split("."), defaults2[key]);
if (canLog)
defaulted[key] = true;
(aliases2[key] || []).forEach(function(x) {
if (hasKey(obj, x.split(".")))
return;
setKey(obj, x.split("."), defaults2[key]);
});
}
});
}
function hasKey(obj, keys) {
let o = obj;
if (!configuration["dot-notation"])
keys = [keys.join(".")];
keys.slice(0, -1).forEach(function(key2) {
o = o[key2] || {};
});
const key = keys[keys.length - 1];
if (typeof o !== "object")
return false;
else
return key in o;
}
function setKey(obj, keys, value) {
let o = obj;
if (!configuration["dot-notation"])
keys = [keys.join(".")];
keys.slice(0, -1).forEach(function(key2, index) {
key2 = sanitizeKey(key2);
if (typeof o === "object" && o[key2] === void 0) {
o[key2] = {};
}
if (typeof o[key2] !== "object" || Array.isArray(o[key2])) {
if (Array.isArray(o[key2])) {
o[key2].push({});
} else {
o[key2] = [o[key2], {}];
}
o = o[key2][o[key2].length - 1];
} else {
o = o[key2];
}
});
const key = sanitizeKey(keys[keys.length - 1]);
const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
const isValueArray = Array.isArray(value);
let duplicate = configuration["duplicate-arguments-array"];
if (!duplicate && checkAllAliases(key, flags.nargs)) {
duplicate = true;
if (!isUndefined(o[key]) && flags.nargs[key] === 1 || Array.isArray(o[key]) && o[key].length === flags.nargs[key]) {
o[key] = void 0;
}
}
if (value === increment) {
o[key] = increment(o[key]);
} else if (Array.isArray(o[key])) {
if (duplicate && isTypeArray && isValueArray) {
o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
} else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
o[key] = value;
} else {
o[key] = o[key].concat([value]);
}
} else if (o[key] === void 0 && isTypeArray) {
o[key] = isValueArray ? value : [value];
} else if (duplicate && !(o[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) {
o[key] = [o[key], value];
} else {
o[key] = value;
}
}
function extendAliases(...args2) {
args2.forEach(function(obj) {
Object.keys(obj || {}).forEach(function(key) {
if (flags.aliases[key])
return;
flags.aliases[key] = [].concat(aliases[key] || []);
flags.aliases[key].concat(key).forEach(function(x) {
if (/-/.test(x) && configuration["camel-case-expansion"]) {
const c = camelCase(x);
if (c !== key && flags.aliases[key].indexOf(c) === -1) {
flags.aliases[key