gedcom/dist/cli.mjs

a simple and readable gedcom parser

#!/usr/bin/env node
import { createRequire } from "node:module";
import * as Fs from "node:fs";
import fs$1 from "node:fs";
import * as Path from "node:path";
import path$1, { dirname } from "node:path";
import process$1 from "node:process";
import require$$0$1, { format } from "util";
import { normalize, resolve } from "path";
import { readFileSync } from "fs";
import { fileURLToPath } from "node:url";
import require$$0$2 from "os";
import require$$0 from "url";

//#region rolldown:runtime
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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (var keys$7 = __getOwnPropNames(from), i = 0, n = keys$7.length, key$1; i < n; i++) {
			key$1 = keys$7[i];
			if (!__hasOwnProp.call(to, key$1) && key$1 !== except) {
				__defProp(to, key$1, {
					get: ((k) => from[k]).bind(null, key$1),
					enumerable: !(desc = __getOwnPropDesc(from, key$1)) || desc.enumerable
				});
			}
		}
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __require = /* @__PURE__ */ createRequire(import.meta.url);

//#endregion
//#region node_modules/.pnpm/get-stdin@9.0.0/node_modules/get-stdin/index.js
const { stdin } = process;
async function getStdin() {
	let result = "";
	if (stdin.isTTY) return result;
	stdin.setEncoding("utf8");
	for await (const chunk of stdin) result += chunk;
	return result;
}
getStdin.buffer = async () => {
	const result = [];
	let length = 0;
	if (stdin.isTTY) return Buffer.concat([]);
	for await (const chunk of stdin) {
		result.push(chunk);
		length += chunk.length;
	}
	return Buffer.concat(result, length);
};

//#endregion
//#region node_modules/.pnpm/meow@13.2.0/node_modules/meow/build/dependencies.js
function camelCase$1(str) {
	if (!(str !== str.toLowerCase() && str !== str.toUpperCase())) str = str.toLowerCase();
	if (str.indexOf("-") === -1 && str.indexOf("_") === -1) return str;
	else {
		let camelcase = "";
		let nextChrUpper = false;
		const leadingHyphens = str.match(/^-+/);
		for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
			let chr = str.charAt(i);
			if (nextChrUpper) {
				nextChrUpper = false;
				chr = chr.toUpperCase();
			}
			if (i !== 0 && (chr === "-" || chr === "_")) nextChrUpper = true;
			else if (chr !== "-" && chr !== "_") camelcase += chr;
		}
		return camelcase;
	}
}
function decamelize$1(str, joinString) {
	const lowercase = str.toLowerCase();
	joinString = joinString || "-";
	let notCamelcase = "";
	for (let i = 0; i < str.length; i++) {
		const chrLower = lowercase.charAt(i);
		const chrString = str.charAt(i);
		if (chrLower !== chrString && i > 0) notCamelcase += `${joinString}${lowercase.charAt(i)}`;
		else notCamelcase += chrString;
	}
	return notCamelcase;
}
function looksLikeNumber(x) {
	if (x === null || x === void 0) return false;
	if (typeof x === "number") return true;
	if (/^0x[0-9a-f]+$/i.test(x)) return true;
	if (/^0[^.]/.test(x)) return false;
	return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
}
function tokenizeArgString(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;
}
var DefaultValuesForTypeKey;
(function(DefaultValuesForTypeKey$1) {
	DefaultValuesForTypeKey$1["BOOLEAN"] = "boolean";
	DefaultValuesForTypeKey$1["STRING"] = "string";
	DefaultValuesForTypeKey$1["NUMBER"] = "number";
	DefaultValuesForTypeKey$1["ARRAY"] = "array";
})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
let mixin;
var YargsParser = class {
	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 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,
			"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$1 = 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.__ || mixin.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 = /* @__PURE__ */ new RegExp("^--" + configuration["negation-prefix"] + "(.+)");
		[].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
			const key$1 = typeof opt === "object" ? opt.key : opt;
			const assignment = Object.keys(opt).map(function(key$2) {
				return {
					boolean: "bools",
					string: "strings",
					number: "numbers"
				}[key$2];
			}).filter(Boolean).pop();
			if (assignment) flags[assignment][key$1] = true;
			flags.arrays[key$1] = true;
			flags.keys.push(key$1);
		});
		[].concat(opts.boolean || []).filter(Boolean).forEach(function(key$1) {
			flags.bools[key$1] = true;
			flags.keys.push(key$1);
		});
		[].concat(opts.string || []).filter(Boolean).forEach(function(key$1) {
			flags.strings[key$1] = true;
			flags.keys.push(key$1);
		});
		[].concat(opts.number || []).filter(Boolean).forEach(function(key$1) {
			flags.numbers[key$1] = true;
			flags.keys.push(key$1);
		});
		[].concat(opts.count || []).filter(Boolean).forEach(function(key$1) {
			flags.counts[key$1] = true;
			flags.keys.push(key$1);
		});
		[].concat(opts.normalize || []).filter(Boolean).forEach(function(key$1) {
			flags.normalize[key$1] = true;
			flags.keys.push(key$1);
		});
		if (typeof opts.narg === "object") Object.entries(opts.narg).forEach(([key$1, value]) => {
			if (typeof value === "number") {
				flags.nargs[key$1] = value;
				flags.keys.push(key$1);
			}
		});
		if (typeof opts.coerce === "object") Object.entries(opts.coerce).forEach(([key$1, value]) => {
			if (typeof value === "function") {
				flags.coercions[key$1] = value;
				flags.keys.push(key$1);
			}
		});
		if (typeof opts.config !== "undefined") {
			if (Array.isArray(opts.config) || typeof opts.config === "string") [].concat(opts.config).filter(Boolean).forEach(function(key$1) {
				flags.configs[key$1] = true;
			});
			else if (typeof opts.config === "object") Object.entries(opts.config).forEach(([key$1, value]) => {
				if (typeof value === "boolean" || typeof value === "function") flags.configs[key$1] = value;
			});
		}
		extendAliases(opts.key, aliases, opts.default, flags.arrays);
		Object.keys(defaults$1).forEach(function(key$1) {
			(flags.aliases[key$1] || []).forEach(function(alias) {
				defaults$1[alias] = defaults$1[key$1];
			});
		});
		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];
			const truncatedArg = arg.replace(/^-{3,}/, "---");
			let broken;
			let key$1;
			let letters;
			let m;
			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(/^-.+=/)) {
				m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
				if (m !== null && Array.isArray(m) && m.length >= 3) 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], true);
			} else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
				m = arg.match(negatedBoolean);
				if (m !== null && Array.isArray(m) && m.length >= 2) {
					key$1 = m[1];
					setArg(key$1, checkAllAliases(key$1, flags.arrays) ? [false] : false);
				}
			} else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
				m = arg.match(/^--?(.+)/);
				if (m !== null && Array.isArray(m) && m.length >= 2) {
					key$1 = m[1];
					if (checkAllAliases(key$1, flags.arrays)) i = eatArray(i, key$1, args);
					else if (checkAllAliases(key$1, flags.nargs) !== false) i = eatNargs(i, key$1, args);
					else {
						next = args[i + 1];
						if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key$1, flags.bools) && !checkAllAliases(key$1, flags.counts)) {
							setArg(key$1, next);
							i++;
						} else if (/^(true|false)$/.test(next)) {
							setArg(key$1, next);
							i++;
						} else setArg(key$1, defaultValue(key$1));
					}
				}
			} else if (arg.match(/^-.\..+=/)) {
				m = arg.match(/^-([^=]+)=([\s\S]*)$/);
				if (m !== null && Array.isArray(m) && m.length >= 3) setArg(m[1], m[2]);
			} else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
				next = args[i + 1];
				m = arg.match(/^-(.\..+)/);
				if (m !== null && Array.isArray(m) && m.length >= 2) {
					key$1 = m[1];
					if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key$1, flags.bools) && !checkAllAliases(key$1, flags.counts)) {
						setArg(key$1, next);
						i++;
					} else setArg(key$1, defaultValue(key$1));
				}
			} 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$1 = letters[j];
						if (checkAllAliases(key$1, flags.arrays)) i = eatArray(i, key$1, args, value);
						else if (checkAllAliases(key$1, flags.nargs) !== false) i = eatNargs(i, key$1, args, value);
						else setArg(key$1, value);
						broken = true;
						break;
					}
					if (next === "-") {
						setArg(letters[j], next);
						continue;
					}
					if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) {
						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$1 = arg.slice(-1)[0];
				if (!broken && key$1 !== "-") if (checkAllAliases(key$1, flags.arrays)) i = eatArray(i, key$1, args);
				else if (checkAllAliases(key$1, flags.nargs) !== false) i = eatNargs(i, key$1, args);
				else {
					next = args[i + 1];
					if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key$1, flags.bools) && !checkAllAliases(key$1, flags.counts)) {
						setArg(key$1, next);
						i++;
					} else if (/^(true|false)$/.test(next)) {
						setArg(key$1, next);
						i++;
					} else setArg(key$1, defaultValue(key$1));
				}
			} else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
				key$1 = arg.slice(1);
				setArg(key$1, defaultValue(key$1));
			} else if (arg === "--") {
				notFlags = args.slice(i + 1);
				break;
			} else if (configuration["halt-at-non-option"]) {
				notFlags = args.slice(i);
				break;
			} else pushPositional(arg);
		}
		applyEnvVars(argv, true);
		applyEnvVars(argv, false);
		setConfig(argv);
		setConfigObjects();
		applyDefaultsAndAliases(argv, flags.aliases, defaults$1, true);
		applyCoercions(argv);
		if (configuration["set-placeholder-key"]) setPlaceholderKeys(argv);
		Object.keys(flags.counts).forEach(function(key$1) {
			if (!hasKey(argv, key$1.split("."))) setArg(key$1, 0);
		});
		if (notFlagsOption && notFlags.length) argv[notFlagsArgv] = [];
		notFlags.forEach(function(key$1) {
			argv[notFlagsArgv].push(key$1);
		});
		if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) Object.keys(argv).filter((key$1) => key$1 !== "--" && key$1.includes("-")).forEach((key$1) => {
			delete argv[key$1];
		});
		if (configuration["strip-aliased"]) [].concat(...Object.keys(aliases).map((k) => aliases[k])).forEach((alias) => {
			if (configuration["camel-case-expansion"] && alias.includes("-")) delete argv[alias.split(".").map((prop) => camelCase$1(prop)).join(".")];
			delete argv[alias];
		});
		function pushPositional(arg) {
			const maybeCoercedNumber = maybeCoerceNumber("_", arg);
			if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") argv._.push(maybeCoercedNumber);
		}
		function eatNargs(i, key$1, args$1, argAfterEqualSign) {
			let ii;
			let toEat = checkAllAliases(key$1, flags.nargs);
			toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
			if (toEat === 0) {
				if (!isUndefined$1(argAfterEqualSign)) error = Error(__("Argument unexpected for: %s", key$1));
				setArg(key$1, defaultValue(key$1));
				return i;
			}
			let available = isUndefined$1(argAfterEqualSign) ? 0 : 1;
			if (configuration["nargs-eats-options"]) {
				if (args$1.length - (i + 1) + available < toEat) error = Error(__("Not enough arguments following: %s", key$1));
				available = toEat;
			} else {
				for (ii = i + 1; ii < args$1.length; ii++) if (!args$1[ii].match(/^-[^0-9]/) || args$1[ii].match(negative) || isUnknownOptionAsArg(args$1[ii])) available++;
				else break;
				if (available < toEat) error = Error(__("Not enough arguments following: %s", key$1));
			}
			let consumed = Math.min(available, toEat);
			if (!isUndefined$1(argAfterEqualSign) && consumed > 0) {
				setArg(key$1, argAfterEqualSign);
				consumed--;
			}
			for (ii = i + 1; ii < consumed + i + 1; ii++) setArg(key$1, args$1[ii]);
			return i + consumed;
		}
		function eatArray(i, key$1, args$1, argAfterEqualSign) {
			let argsToSet = [];
			let next = argAfterEqualSign || args$1[i + 1];
			const nargsCount = checkAllAliases(key$1, flags.nargs);
			if (checkAllAliases(key$1, flags.bools) && !/^(true|false)$/.test(next)) argsToSet.push(true);
			else if (isUndefined$1(next) || isUndefined$1(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
				if (defaults$1[key$1] !== void 0) {
					const defVal = defaults$1[key$1];
					argsToSet = Array.isArray(defVal) ? defVal : [defVal];
				}
			} else {
				if (!isUndefined$1(argAfterEqualSign)) argsToSet.push(processValue(key$1, argAfterEqualSign, true));
				for (let ii = i + 1; ii < args$1.length; ii++) {
					if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount) break;
					next = args$1[ii];
					if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) break;
					i = ii;
					argsToSet.push(processValue(key$1, next, inputIsString));
				}
			}
			if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) error = Error(__("Not enough arguments following: %s", key$1));
			setArg(key$1, argsToSet);
			return i;
		}
		function setArg(key$1, val, shouldStripQuotes = inputIsString) {
			if (/-/.test(key$1) && configuration["camel-case-expansion"]) addNewAlias(key$1, key$1.split(".").map(function(prop) {
				return camelCase$1(prop);
			}).join("."));
			const value = processValue(key$1, val, shouldStripQuotes);
			const splitKey = key$1.split(".");
			setKey(argv, splitKey, value);
			if (flags.aliases[key$1]) flags.aliases[key$1].forEach(function(x) {
				setKey(argv, x.split("."), value);
			});
			if (splitKey.length > 1 && configuration["dot-notation"]) (flags.aliases[splitKey[0]] || []).forEach(function(x) {
				let keyProperties = x.split(".");
				const a = [].concat(splitKey);
				a.shift();
				keyProperties = keyProperties.concat(a);
				if (!(flags.aliases[key$1] || []).includes(keyProperties.join("."))) setKey(argv, keyProperties, value);
			});
			if (checkAllAliases(key$1, flags.normalize) && !checkAllAliases(key$1, flags.arrays)) [key$1].concat(flags.aliases[key$1] || []).forEach(function(key$2) {
				Object.defineProperty(argvReturn, key$2, {
					enumerable: true,
					get() {
						return val;
					},
					set(value$1) {
						val = typeof value$1 === "string" ? mixin.normalize(value$1) : value$1;
					}
				});
			});
		}
		function addNewAlias(key$1, alias) {
			if (!(flags.aliases[key$1] && flags.aliases[key$1].length)) {
				flags.aliases[key$1] = [alias];
				newAliases[alias] = true;
			}
			if (!(flags.aliases[alias] && flags.aliases[alias].length)) addNewAlias(alias, key$1);
		}
		function processValue(key$1, val, shouldStripQuotes) {
			if (shouldStripQuotes) val = stripQuotes(val);
			if (checkAllAliases(key$1, flags.bools) || checkAllAliases(key$1, flags.counts)) {
				if (typeof val === "string") val = val === "true";
			}
			let value = Array.isArray(val) ? val.map(function(v) {
				return maybeCoerceNumber(key$1, v);
			}) : maybeCoerceNumber(key$1, val);
			if (checkAllAliases(key$1, flags.counts) && (isUndefined$1(value) || typeof value === "boolean")) value = increment();
			if (checkAllAliases(key$1, flags.normalize) && checkAllAliases(key$1, flags.arrays)) if (Array.isArray(val)) value = val.map((val$1) => {
				return mixin.normalize(val$1);
			});
			else value = mixin.normalize(val);
			return value;
		}
		function maybeCoerceNumber(key$1, value) {
			if (!configuration["parse-positional-numbers"] && key$1 === "_") return value;
			if (!checkAllAliases(key$1, flags.strings) && !checkAllAliases(key$1, flags.bools) && !Array.isArray(value)) {
				if (looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`))) || !isUndefined$1(value) && checkAllAliases(key$1, flags.numbers)) value = Number(value);
			}
			return value;
		}
		function setConfig(argv$1) {
			const configLookup = Object.create(null);
			applyDefaultsAndAliases(configLookup, flags.aliases, defaults$1);
			Object.keys(flags.configs).forEach(function(configKey) {
				const configPath = argv$1[configKey] || configLookup[configKey];
				if (configPath) try {
					let config = null;
					const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
					const resolveConfig = flags.configs[configKey];
					if (typeof resolveConfig === "function") {
						try {
							config = resolveConfig(resolvedConfigPath);
						} catch (e) {
							config = e;
						}
						if (config instanceof Error) {
							error = config;
							return;
						}
					} else config = mixin.require(resolvedConfigPath);
					setConfigObject(config);
				} catch (ex) {
					if (ex.name === "PermissionDenied") error = ex;
					else if (argv$1[configKey]) error = Error(__("Invalid JSON config file: %s", configPath));
				}
			});
		}
		function setConfigObject(config, prev) {
			Object.keys(config).forEach(function(key$1) {
				const value = config[key$1];
				const fullKey = prev ? prev + "." + key$1 : key$1;
				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") configObjects.forEach(function(configObject) {
				setConfigObject(configObject);
			});
		}
		function applyEnvVars(argv$1, configOnly) {
			if (typeof envPrefix === "undefined") return;
			const prefix = typeof envPrefix === "string" ? envPrefix : "";
			const env$3 = mixin.env();
			Object.keys(env$3).forEach(function(envVar) {
				if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
					const keys$7 = envVar.split("__").map(function(key$1, i) {
						if (i === 0) key$1 = key$1.substring(prefix.length);
						return camelCase$1(key$1);
					});
					if ((configOnly && flags.configs[keys$7.join(".")] || !configOnly) && !hasKey(argv$1, keys$7)) setArg(keys$7.join("."), env$3[envVar]);
				}
			});
		}
		function applyCoercions(argv$1) {
			let coerce;
			const applied = /* @__PURE__ */ new Set();
			Object.keys(argv$1).forEach(function(key$1) {
				if (!applied.has(key$1)) {
					coerce = checkAllAliases(key$1, flags.coercions);
					if (typeof coerce === "function") try {
						const value = maybeCoerceNumber(key$1, coerce(argv$1[key$1]));
						[].concat(flags.aliases[key$1] || [], key$1).forEach((ali) => {
							applied.add(ali);
							argv$1[ali] = value;
						});
					} catch (err) {
						error = err;
					}
				}
			});
		}
		function setPlaceholderKeys(argv$1) {
			flags.keys.forEach((key$1) => {
				if (~key$1.indexOf(".")) return;
				if (typeof argv$1[key$1] === "undefined") argv$1[key$1] = void 0;
			});
			return argv$1;
		}
		function applyDefaultsAndAliases(obj, aliases$1, defaults$2, canLog = false) {
			Object.keys(defaults$2).forEach(function(key$1) {
				if (!hasKey(obj, key$1.split("."))) {
					setKey(obj, key$1.split("."), defaults$2[key$1]);
					if (canLog) defaulted[key$1] = true;
					(aliases$1[key$1] || []).forEach(function(x) {
						if (hasKey(obj, x.split("."))) return;
						setKey(obj, x.split("."), defaults$2[key$1]);
					});
				}
			});
		}
		function hasKey(obj, keys$7) {
			let o = obj;
			if (!configuration["dot-notation"]) keys$7 = [keys$7.join(".")];
			keys$7.slice(0, -1).forEach(function(key$2) {
				o = o[key$2] || {};
			});
			const key$1 = keys$7[keys$7.length - 1];
			if (typeof o !== "object") return false;
			else return key$1 in o;
		}
		function setKey(obj, keys$7, value) {
			let o = obj;
			if (!configuration["dot-notation"]) keys$7 = [keys$7.join(".")];
			keys$7.slice(0, -1).forEach(function(key$2) {
				key$2 = sanitizeKey(key$2);
				if (typeof o === "object" && o[key$2] === void 0) o[key$2] = {};
				if (typeof o[key$2] !== "object" || Array.isArray(o[key$2])) {
					if (Array.isArray(o[key$2])) o[key$2].push({});
					else o[key$2] = [o[key$2], {}];
					o = o[key$2][o[key$2].length - 1];
				} else o = o[key$2];
			});
			const key$1 = sanitizeKey(keys$7[keys$7.length - 1]);
			const isTypeArray = checkAllAliases(keys$7.join("."), flags.arrays);
			const isValueArray = Array.isArray(value);
			let duplicate = configuration["duplicate-arguments-array"];
			if (!duplicate && checkAllAliases(key$1, flags.nargs)) {
				duplicate = true;
				if (!isUndefined$1(o[key$1]) && flags.nargs[key$1] === 1 || Array.isArray(o[key$1]) && o[key$1].length === flags.nargs[key$1]) o[key$1] = void 0;
			}
			if (value === increment()) o[key$1] = increment(o[key$1]);
			else if (Array.isArray(o[key$1])) if (duplicate && isTypeArray && isValueArray) o[key$1] = configuration["flatten-duplicate-arrays"] ? o[key$1].concat(value) : (Array.isArray(o[key$1][0]) ? o[key$1] : [o[key$1]]).concat([value]);
			else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) o[key$1] = value;
			else o[key$1] = o[key$1].concat([value]);
			else if (o[key$1] === void 0 && isTypeArray) o[key$1] = isValueArray ? value : [value];
			else if (duplicate && !(o[key$1] === void 0 || checkAllAliases(key$1, flags.counts) || checkAllAliases(key$1, flags.bools))) o[key$1] = [o[key$1], value];
			else o[key$1] = value;
		}
		function extendAliases(...args$1) {
			args$1.forEach(function(obj) {
				Object.keys(obj || {}).forEach(function(key$1) {
					if (flags.aliases[key$1]) return;
					flags.aliases[key$1] = [].concat(aliases[key$1] || []);
					flags.aliases[key$1].concat(key$1).forEach(function(x) {
						if (/-/.test(x) && configuration["camel-case-expansion"]) {
							const c = camelCase$1(x);
							if (c !== key$1 && flags.aliases[key$1].indexOf(c) === -1) {
								flags.aliases[key$1].push(c);
								newAliases[c] = true;
							}
						}
					});
					flags.aliases[key$1].concat(key$1).forEach(function(x) {
						if (x.length > 1 && /[A-Z]/.test(x) && configuration["camel-case-expansion"]) {
							const c = decamelize$1(x, "-");
							if (c !== key$1 && flags.aliases[key$1].indexOf(c) === -1) {
								flags.aliases[key$1].push(c);
								newAliases[c] = true;
							}
						}
					});
					flags.aliases[key$1].forEach(function(x) {
						flags.aliases[x] = [key$1].concat(flags.aliases[key$1].filter(function(y) {
							return x !== y;
						}));
					});
				});
			});
		}
		function checkAllAliases(key$1, flag) {
			const toCheck = [].concat(flags.aliases[key$1] || [], key$1);
			const keys$7 = Object.keys(flag);
			const setAlias = toCheck.find((key$2) => keys$7.includes(key$2));
			return setAlias ? flag[setAlias] : false;
		}
		function hasAnyFlag(key$1) {
			const flagsKeys = Object.keys(flags);
			return [].concat(flagsKeys.map((k) => flags[k])).some(function(flag) {
				return Array.isArray(flag) ? flag.includes(key$1) : flag[key$1];
			});
		}
		function hasFlagsMatching(arg, ...patterns) {
			return [].concat(...patterns).some(function(pattern) {
				const match = arg.match(pattern);
				return match && hasAnyFlag(match[1]);
			});
		}
		function hasAllShortFlags(arg) {
			if (arg.match(negative) || !arg.match(/^-[^-]+/)) return false;
			let hasAllFlags = true;
			let next;
			const letters = arg.slice(1).split("");
			for (let j = 0; j < letters.length; j++) {
				next = arg.slice(j + 2);
				if (!hasAnyFlag(letters[j])) {
					hasAllFlags = false;
					break;
				}
				if (letters[j + 1] && letters[j + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j + 1] && letters[j + 1].match(/\W/)) break;
			}
			return hasAllFlags;
		}
		function isUnknownOptionAsArg(arg) {
			return configuration["unknown-options-as-args"] && isUnknownOption(arg);
		}
		function isUnknownOption(arg) {
			arg = arg.replace(/^-{3,}/, "--");
			if (arg.match(negative)) return false;
			if (hasAllShortFlags(arg)) return false;
			return !hasFlagsMatching(arg, /^-+([^=]+?)=[\s\S]*$/, negatedBoolean, /^-+([^=]+?)$/, /^-+([^=]+?)-$/, /^-+([^=]+?\d+)$/, /^-+([^=]+?)\W+.*$/);
		}
		function defaultValue(key$1) {
			if (!checkAllAliases(key$1, flags.bools) && !checkAllAliases(key$1, flags.counts) && `${key$1}` in defaults$1) return defaults$1[key$1];
			else return defaultForType(guessType(key$1));
		}
		function defaultForType(type) {
			return {
				[DefaultValuesForTypeKey.BOOLEAN]: true,
				[DefaultValuesForTypeKey.STRING]: "",
				[DefaultValuesForTypeKey.NUMBER]: void 0,
				[DefaultValuesForTypeKey.ARRAY]: []
			}[type];
		}
		function guessType(key$1) {
			let type = DefaultValuesForTypeKey.BOOLEAN;
			if (checkAllAliases(key$1, flags.strings)) type = DefaultValuesForTypeKey.STRING;
			else if (checkAllAliases(key$1, flags.numbers)) type = DefaultValuesForTypeKey.NUMBER;
			else if (checkAllAliases(key$1, flags.bools)) type = DefaultValuesForTypeKey.BOOLEAN;
			else if (checkAllAliases(key$1, flags.arrays)) type = DefaultValuesForTypeKey.ARRAY;
			return type;
		}
		function isUndefined$1(num) {
			return num === void 0;
		}
		function checkConfiguration() {
			Object.keys(flags.counts).find((key$1) => {
				if (checkAllAliases(key$1, flags.arrays)) {
					error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key$1));
					return true;
				} else if (checkAllAliases(key$1, flags.nargs)) {
					error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key$1));
					return true;
				}
				return false;
			});
		}
		return {
			aliases: Object.assign({}, flags.aliases),
			argv: Object.assign(argvReturn, argv),
			configuration,
			defaulted: Object.assign({}, defaulted),
			error,
			newAliases: Object.assign({}, newAliases)
		};
	}
};
function combineAliases(aliases) {
	const aliasArrays = [];
	const combined = Object.create(null);
	let change = true;
	Object.keys(aliases).forEach(function(key$1) {
		aliasArrays.push([].concat(aliases[key$1], key$1));
	});
	while (change) {
		change = false;
		for (let i = 0; i < aliasArrays.length; i++) for (let ii = i + 1; ii < aliasArrays.length; ii++) if (aliasArrays[i].filter(function(v) {
			return aliasArrays[ii].indexOf(v) !== -1;
		}).length) {
			aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
			aliasArrays.splice(ii, 1);
			change = true;
			break;
		}
	}
	aliasArrays.forEach(function(aliasArray) {
		aliasArray = aliasArray.filter(function(v, i, self$1) {
			return self$1.indexOf(v) === i;
		});
		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$1) {
	if (key$1 === "__proto__") return "___proto___";
	return key$1;
}
function stripQuotes(val) {
	return typeof val === "string" && (val[0] === "'" || val[0] === "\"") && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val;
}
var _a, _b, _c;
const minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 12;
const 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) {
	if (Number(nodeVersion.match(/^([^.]+)/)[1]) < 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`);
}
const env$2 = process ? process.env : {};
const parser = new YargsParser({
	cwd: process.cwd,
	env: () => {
		return env$2;
	},
	format,
	normalize,
	resolve,
	require: (path$2) => {
		if (typeof __require !== "undefined") return __require(path$2);
		else if (path$2.match(/\.json$/)) return JSON.parse(readFileSync(path$2, "utf8"));
		else throw Error("only .json config files are supported in ESM");
	}
});
const yargsParser = function Parser(args, opts) {
	return parser.parse(args.slice(), opts).argv;
};
yargsParser.detailed = function(args, opts) {
	return parser.parse(args.slice(), opts);
};
yargsParser.camelCase = camelCase$1;
yargsParser.decamelize = decamelize$1;
yargsParser.looksLikeNumber = looksLikeNumber;
const isObject$3$1 = (value) => typeof value === "object" && value !== null;
const isObjectCustom$1 = (value) => isObject$3$1(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
const mapObjectSkip$1 = Symbol("mapObjectSkip");
const _mapObject = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
	options = {
		deep: false,
		target: {},
		...options
	};
	if (isSeen.has(object)) return isSeen.get(object);
	isSeen.set(object, options.target);
	const { target } = options;
	delete options.target;
	const mapArray = (array) => array.map((element) => isObjectCustom$1(element) ? _mapObject(element, mapper, options, isSeen) : element);
	if (Array.isArray(object)) return mapArray(object);
	for (const [key$1, value] of Object.entries(object)) {
		const mapResult = mapper(key$1, value, object);
		if (mapResult === mapObjectSkip$1) continue;
		let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
		if (newKey === "__proto__") continue;
		if (options.deep && shouldRecurse && isObjectCustom$1(newValue)) newValue = Array.isArray(newValue) ? mapArray(newValue) : _mapObject(newValue, mapper, options, isSeen);
		target[newKey] = newValue;
	}
	return target;
};
function mapObject$2(object, mapper, options) {
	if (!isObject$3$1(object)) throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
	return _mapObject(object, mapper, options);
}
const UPPERCASE = /[\p{Lu}]/u;
const LOWERCASE = /[\p{Ll}]/u;
const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
const IDENTIFIER$1 = /([\p{Alpha}\p{N}_]|$)/u;
const SEPARATORS = /[_.\- ]+/;
const LEADING_SEPARATORS = /* @__PURE__ */ new RegExp("^" + SEPARATORS.source);
const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER$1.source, "gu");
const NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER$1.source, "gu");
const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase$1) => {
	let isLastCharLower = false;
	let isLastCharUpper = false;
	let isLastLastCharUpper = false;
	let isLastLastCharPreserved = false;
	for (let index = 0; index < string.length; index++) {
		const character = string[index];
		isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
		if (isLastCharLower && UPPERCASE.test(character)) {
			string = string.slice(0, index) + "-" + string.slice(index);
			isLastCharLower = false;
			isLastLastCharUpper = isLastCharUpper;
			isLastCharUpper = true;
			index++;
		} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase$1)) {
			string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
			isLastLastCharUpper = isLastCharUpper;
			isLastCharUpper = false;
			isLastCharLower = true;
		} else {
			isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
			isLastLastCharUpper = isLastCharUpper;
			isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
		}
	}
	return string;
};
const preserveConsecutiveUppercase = (input, toLowerCase) => {
	LEADING_CAPITAL.lastIndex = 0;
	return input.replaceAll(LEADING_CAPITAL, (match) => toLowerCase(match));
};
const postProcess = (input, toUpperCase) => {
	SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
	NUMBERS_AND_IDENTIFIER.lastIndex = 0;
	return input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)).replaceAll(SEPARATORS_AND_IDENTIFIER, (_$15, identifier$1) => toUpperCase(identifier$1));
};
function camelCase(input, options) {
	if (!(typeof input === "string" || Array.isArray(input))) throw new TypeError("Expected the input to be `string | string[]`");
	options = {
		pascalCase: false,
		preserveConsecutiveUppercase: false,
		...options
	};
	if (Array.isArray(input)) input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
	else input = input.trim();
	if (input.length === 0) return "";
	const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
	const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
	if (input.length === 1) {
		if (SEPARATORS.test(input)) return "";
		return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
	}
	if (input !== toLowerCase(input)) input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
	input = input.replace(LEADING_SEPARATORS, "");
	input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
	if (options.pascalCase) input = toUpperCase(input.charAt(0)) + input.slice(1);
	return postProcess(input, toUpperCase);
}
var QuickLRU = class extends Map {
	constructor(options = {}) {
		super();
		if (!(options.maxSize && options.maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
		if (typeof options.maxAge === "number" && options.maxAge === 0) throw new TypeError("`maxAge` must be a number greater than 0");
		this.maxSize = options.maxSize;
		this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
		this.onEviction = options.onEviction;
		this.cache = /* @__PURE__ */ new Map();
		this.oldCache = /* @__PURE__ */ new Map();
		this._size = 0;
	}
	_emitEvictions(cache$3) {
		if (typeof this.onEviction !== "function") return;
		for (const [key$1, item] of cache$3) this.onEviction(key$1, item.value);
	}
	_deleteIfExpired(key$1, item) {
		if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
			if (typeof this.onEviction === "function") this.onEviction(key$1, item.value);
			return this.delete(key$1);
		}
		return false;
	}
	_getOrDeleteIfExpired(key$1, item) {
		if (this._deleteIfExpired(key$1, item) === false) return item.value;
	}
	_getItemValue(key$1, item) {
		return item.expiry ? this._getOrDeleteIfExpired(key$1, item) : item.value;
	}
	_peek(key$1, cache$3) {
		const item = cache$3.get(key$1);
		return this._getItemValue(key$1, item);
	}
	_set(key$1, value) {
		this.cache.set(key$1, value);
		this._size++;
		if (this._size >= this.maxSize) {
			this._size = 0;
			this._emitEvictions(this.oldCache);
			this.oldCache = this.cache;
			this.cache = /* @__PURE__ */ new Map();
		}
	}
	_moveToRecent(key$1, item) {
		this.oldCache.delete(key$1);
		this._set(key$1, item);
	}
	*_entriesAscending() {
		for (const item of this.oldCache) {
			const [key$1, value] = item;
			if (!this.cache.has(key$1)) {
				if (this._deleteIfExpired(key$1, value) === false) yield item;
			}
		}
		for (const item of this.cache) {
			const [key$1, value] = item;
			if (this._deleteIfExpired(key$1, value) === false) yield item;
		}
	}
	get(key$1) {
		if (this.cache.has(key$1)) {
			const item = this.cache.get(key$1);
			return this._getItemValue(key$1, item);
		}
		if (this.oldCache.has(key$1)) {
			const item = this.oldCache.get(key$1);
			if (this._deleteIfExpired(key$1, item) === false) {
				this._moveToRecent(key$1, item);
				return item.value;
			}
		}
	}
	set(key$1, value, { maxAge = this.maxAge } = {}) {
		const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0;
		if (this.cache.has(key$1)) this.cache.set(key$1, {
			value,
			expiry
		});
		else this._set(key$1, {
			value,
			expiry
		});
		return this;
	}
	has(key$1) {
		if (this.cache.has(key$1)) return !this._deleteIfExpired(key$1, this.cache.get(key$1));
		if (this.oldCache.has(key$1)) return !this._deleteIfExpired(key$1, this.oldCache.get(key$1));
		return false;
	}
	peek(key$1) {
		if (this.cache.has(key$1)) return this._peek(key$1, this.cache);
		if (this.oldCache.has(key$1)) return this._peek(key$1, this.oldCache);
	}
	delete(key$1) {
		const deleted = this.cache.delete(key$1);
		if (deleted) this._size--;
		return this.oldCache.delete(key$1) || deleted;
	}
	clear() {
		this.cache.clear();
		this.oldCache.clear();
		this._size = 0;
	}
	resize(newSize) {
		if (!(newSize && newSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
		const items = [...this._entriesAscending()];
		const removeCount = items.length - newSize;
		if (removeCount < 0) {
			this.cache = new Map(items);
			this.oldCache = /* @__PURE__ */ new Map();
			this._size = items.length;
		} else {
			if (removeCount > 0) this._emitEvictions(items.slice(0, removeCount));
			this.oldCache = new Map(items.slice(removeCount));
			this.cache = /* @__PURE__ */ new Map();
			this._size = 0;
		}
		this.maxSize = newSize;
	}
	*keys() {
		for (const [key$1] of this) yield key$1;
	}
	*values() {
		for (const [, value] of this) yield value;
	}
	*[Symbol.iterator]() {
		for (const item of this.cache) {
			const [key$1, value] = item;
			if (this._deleteIfExpired(key$1, value) === false) yield [key$1, value.value];
		}
		for (const item of this.oldCache) {
			const [key$1, value] = item;
			if (!this.cache.has(key$1)) {
				if (this._deleteIfExpired(key$1, value) === false) yield [key$1, value.value];
			}
		}
	}
	*entriesDescending() {
		let items = [...this.cache];
		for (let i = items.length - 1; i >= 0; --i) {
			const [key$1, value] = items[i];
			if (this._deleteIfExpired(key$1, value) === false) yield [key$1, value.value];
		}
		items = [...this.oldCache];
		for (let i = items.length - 1; i >= 0; --i) {
			const [key$1, value] = items[i];
			if (!this.cache.has(key$1)) {
				if (this._deleteIfExpired(key$1, value) === false) yield [key$1, value.value];
			}
		}
	}
	*entriesAscending() {
		for (const [key$1, value] of this._entriesAscending()) yield [key$1, value.value];
	}
	get size() {
		if (!this._size) return this.oldCache.size;
		let oldCacheSize = 0;
		for (const key$1 of this.oldCache.keys()) if (!this.cache.has(key$1)) oldCacheSize++;
		return Math.min(this._size + oldCacheSize, this.maxSize);
	}
	entries() {
		return this.entriesAscending();
	}
	forEach(callbackFunction, thisArgument = this) {
		for (const [key$1, value] of this.entriesAscending()) callbackFunction.call(thisArgument, value, key$1, this);
	}
	get [Symbol.toStringTag]() {
		return JSON.stringify([...this.entriesAscending()]);
	}
};
const has$1 = (array, key$1) => array.some((element) => {
	if (typeof element === "string") return element === key$1;
	element.lastIndex = 0;
	return element.test(key$1);
});
const cache$2 = new QuickLRU({ maxSize: 1e5 });
const isObject$2$1 = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
const transform$1 = (input, options = {}) => {
	if (!isObject$2$1(input)) return input;
	const { exclude, pascalCase = false, stopPaths, deep = false, preserveConsecutiveUppercase: preserveConsecutiveUppercase$1 = false } = options;
	const stopPathsSet = new Set(stopPaths);
	const makeMapper = (parentPath) => (key$1, value) => {
		if (deep && isObject$2$1(value)) {
			const path$2 = parentPath === void 0 ? key$1 : `${parentPath}.${key$1}`;
			if (!stopPathsSet.has(path$2)) value = mapObject$2(value, makeMapper(path$2));
		}
		if (!(exclude && has$1(exclude, key$1))) {
			const cacheKey = pascalCase ? `${key$1}_` : key$1;
			if (cache$2.has(cacheKey)) key$1 = cache$2.get(cacheKey);
			else {
				const returnValue = camelCase(key$1, {
					pascalCase,
					locale: false,
					preserveConsecutiveUppercase: preserveConsecutiveUppercase$1
				});
				if (key$1.length < 100) cache$2.set(cacheKey, returnValue);
				key$1 = returnValue;
			}
		}
		return [key$1, value];
	};
	return mapObject$2(input, makeMapper(void 0));
};
function camelcaseKeys(input, options) {
	if (Array.isArray(input)) return Object.keys(input).map((key$1) => transform$1(input[key$1], options));
	return transform$1(input, options);
}
function trimNewlines(string) {
	let start = 0;
	let end = string.length;
	while (start < end && (string[start] === "\r" || string[start] === "\n")) start++;
	while (end > start && (string[end - 1] === "\r" || string[end - 1] === "\n")) end--;
	return start > 0 || end < string.length ? string.slice(start, end) : string;
}
function getDefaultExportFromCjs(x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var minIndent = (string) => {
	const match = string.match(/^[ \t]*(?=\S)/gm);
	if (!match) return 0;
	return match.reduce((r, a) => Math.min(r, a.length), Infinity);
};
const minIndent$1 = getDefaultExportFromCjs(minIndent);
function stripIndent(string) {
	const indent = minIndent$1(string);
	if (indent === 0) return string;
	const regex = new RegExp(`^[ \\t]{${indent}}`, "gm");
	return string.replace(regex, "");
}
function indentString(string, count = 1, options = {}) {
	const { indent = " ", includeEmptyLines = false } = options;
	if (typeof string !== "string") throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof string}\``);
	if (typeof count !== "number") throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
	if (count < 0) throw new RangeError(`Expected \`count\` to be at least 0, got \`${count}\``);
	if (typeof indent !== "string") throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``);
	if (count === 0) return string;
	const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
	return string.replace(regex, indent.repeat(count));
}
function redent(string, count = 0, options = {}) {
	return indentString(stripIndent(string), count, options);
}
var debug_1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
const SEMVER_SPEC_VERSION = "2.0.0";
const MAX_LENGTH$1 = 256;
const MAX_SAFE_INTEGER$1$1 = Number.MAX_SAFE_INTEGER || 9007199254740991;
var constants$1 = {
	MAX_LENGTH: MAX_LENGTH$1,
	MAX_SAFE_COMPONENT_LENGTH: 16,
	MAX_SAFE_BUILD_LENGTH: MAX_LENGTH$1 - 6,
	MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1$1,
	RELEASE_TYPES: [
		"major",
		"premajor",
		"minor",
		"preminor",
		"patch",
		"prepatch",
		"prerelease"
	],
	SEMVER_SPEC_VERSION,
	FLAG_INCLUDE_PRERELEASE: 1,
	FLAG_LOOSE: 2
};
var re$1 = { exports: {} };
(function(module$2, exports$1) {
	const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH: MAX_LENGTH$2 } = constants$1;
	const debug$1 = debug_1;
	exports$1 = module$2.exports = {};
	const re$2 = exports$1.re = [];
	const safeRe = exports$1.safeRe = [];
	const src = exports$1.src = [];
	const t$1 = exports$1.t = {};
	let R = 0;
	const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
	const safeRegexReplacements = [
		["\\s", 1],
		["\\d", MAX_LENGTH$2],
		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
	];
	const makeSafeRegex = (value) => {
		for (const [token, max$1] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max$1}}`).split(`${token}+`).join(`${token}{1,${max$1}}`);
		return value;
	};
	const createToken = (name, value, isGlobal) => {
		const safe = makeSafeRegex(value);
		const index = R++;
		debug$1(name, index, value);
		t$1[name] = index;
		src[index] = value;
		re$2[index] = new RegExp(value, isGlobal ? "g" : void 0);
		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
	};
	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
	createToken("MAINVERSION", `(${src[t$1.NUMERICIDENTIFIER]})\\.(${src[t$1.NUMERICIDENTIFIER]})\\.(${src[t$1.NUMERICIDENTIFIER]})`);
	createToken("MAINVERSIONLOOSE", `(${src[t$1.NUMERICIDENTIFIERLOOSE]})\\.(${src[t$1.NUMERICIDENTIFIERLOOSE]})\\.(${src[t$1.NUMERICIDENTIFIERLOOSE]})`);
	createToken("PRERELEASEIDENTIFIER", `(?:${src[t$1.NUMERICIDENTIFIER]}|${src[t$1.NONNUMERICIDENTIFIER]})`);
	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t$1.NUMERICIDENTIFIERLOOSE]}|${src[t$1.NONNUMERICIDENTIFIER]})`);
	createToken("PRERELEASE", `(?:-(${src[t$1.PRERELEASEIDENTIFIER]}(?:\\.${src[t$1.PRERELEASEIDENTIFIER]})*))`);
	createToken("PRERELEASELOOSE", `(?:-?(${src[t$1.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t$1.PRERELEASEIDENTIFIERLOOSE]})*))`);
	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
	createToken("BUILD", `(?:\\+(${src[t$1.BUILDIDENTIFIER]}(?:\\.${src[t$1.BUILDIDENTIFIER]})*))`);
	createToken("FULLPLAIN", `v?${src[t$1.MAINVERSION]}${src[t$1.PRERELEASE]}?${src[t$1.BUILD]}?`);
	createToken("FULL", `^${src[t$1.FULLPLAIN]}$`);
	createToken("LOOSEPLAIN", `[v=\\s]*${src[t$1.MAINVERSIONLOOSE]}${src[t$1.PRERELEASELOOSE]}?${src[t$1.BUILD]}?`);
	createToken("LOOSE", `^${src[t$1.LOOSEPLAIN]}$`);
	createToken("GTLT", "((?:<|>)?=?)");
	createToken("XRANGEIDENTIFIERLOOSE", `${src[t$1.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
	createToken("XRANGEIDENTIFIER", `${src[t$1.NUMERICIDENTIFIER]}|x|X|\\*`);
	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t$1.XRANGEIDENTIFIER]})(?:\\.(${src[t$1.XRANGEIDENTIFIER]})(?:\\.(${src[t$1.XRANGEIDENTIFIER]})(?:${src[t$1.PRERELEASE]})?${src[t$1.BUILD]}?)?)?`);
	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t$1.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t$1.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t$1.XRANGEIDENTIFIERLOOSE]})(?:${src[t$1.PRERELEASELOOSE]})?${src[t$1.BUILD]}?)?)?`);
	createToken("XRANGE", `^${src[t$1.GTLT]}\\s*${src[t$1.XRANGEPLAIN]}$`);
	createToken("XRANGELOOSE", `^${src[t$1.GTLT]}\\s*${src[t$1.XRANGEPLAINLOOSE]}$`);
	createToken("COER