cmte
Version:
Design by Committee™ except it's just you and LLMs
1,577 lines (1,549 loc) • 2.18 MB
JavaScript
#!/usr/bin/env node
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 __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
get: (a2, b2) => (typeof require !== "undefined" ? require : a2)[b2]
}) : x2)(function(x2) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw Error('Dynamic require of "' + x2 + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all2) => {
for (var name in all2)
__defProp(target, name, { get: all2[name], 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 __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
));
// node_modules/dotenv/package.json
var require_package = __commonJS({
"node_modules/dotenv/package.json"(exports2, module2) {
module2.exports = {
name: "dotenv",
version: "16.4.7",
description: "Loads environment variables from .env file",
main: "lib/main.js",
types: "lib/main.d.ts",
exports: {
".": {
types: "./lib/main.d.ts",
require: "./lib/main.js",
default: "./lib/main.js"
},
"./config": "./config.js",
"./config.js": "./config.js",
"./lib/env-options": "./lib/env-options.js",
"./lib/env-options.js": "./lib/env-options.js",
"./lib/cli-options": "./lib/cli-options.js",
"./lib/cli-options.js": "./lib/cli-options.js",
"./package.json": "./package.json"
},
scripts: {
"dts-check": "tsc --project tests/types/tsconfig.json",
lint: "standard",
pretest: "npm run lint && npm run dts-check",
test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
"test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=lcov",
prerelease: "npm test",
release: "standard-version"
},
repository: {
type: "git",
url: "git://github.com/motdotla/dotenv.git"
},
funding: "https://dotenvx.com",
keywords: [
"dotenv",
"env",
".env",
"environment",
"variables",
"config",
"settings"
],
readmeFilename: "README.md",
license: "BSD-2-Clause",
devDependencies: {
"@types/node": "^18.11.3",
decache: "^4.6.2",
sinon: "^14.0.1",
standard: "^17.0.0",
"standard-version": "^9.5.0",
tap: "^19.2.0",
typescript: "^4.8.4"
},
engines: {
node: ">=12"
},
browser: {
fs: false
}
};
}
});
// node_modules/dotenv/lib/main.js
var require_main = __commonJS({
"node_modules/dotenv/lib/main.js"(exports2, module2) {
var fs9 = __require("fs");
var path16 = __require("path");
var os2 = __require("os");
var crypto = __require("crypto");
var packageJson = require_package();
var version = packageJson.version;
var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
function parse5(src) {
const obj = {};
let lines = src.toString();
lines = lines.replace(/\r\n?/mg, "\n");
let match2;
while ((match2 = LINE.exec(lines)) != null) {
const key = match2[1];
let value = match2[2] || "";
value = value.trim();
const maybeQuote = value[0];
value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
if (maybeQuote === '"') {
value = value.replace(/\\n/g, "\n");
value = value.replace(/\\r/g, "\r");
}
obj[key] = value;
}
return obj;
}
function _parseVault(options2) {
const vaultPath = _vaultPath(options2);
const result = DotenvModule.configDotenv({ path: vaultPath });
if (!result.parsed) {
const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
err.code = "MISSING_DATA";
throw err;
}
const keys = _dotenvKey(options2).split(",");
const length = keys.length;
let decrypted;
for (let i2 = 0; i2 < length; i2++) {
try {
const key = keys[i2].trim();
const attrs = _instructions(result, key);
decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
break;
} catch (error) {
if (i2 + 1 >= length) {
throw error;
}
}
}
return DotenvModule.parse(decrypted);
}
function _log(message) {
console.log(`[dotenv@${version}][INFO] ${message}`);
}
function _warn(message) {
console.log(`[dotenv@${version}][WARN] ${message}`);
}
function _debug(message) {
console.log(`[dotenv@${version}][DEBUG] ${message}`);
}
function _dotenvKey(options2) {
if (options2 && options2.DOTENV_KEY && options2.DOTENV_KEY.length > 0) {
return options2.DOTENV_KEY;
}
if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
return process.env.DOTENV_KEY;
}
return "";
}
function _instructions(result, dotenvKey) {
let uri;
try {
uri = new URL(dotenvKey);
} catch (error) {
if (error.code === "ERR_INVALID_URL") {
const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
throw error;
}
const key = uri.password;
if (!key) {
const err = new Error("INVALID_DOTENV_KEY: Missing key part");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
const environment = uri.searchParams.get("environment");
if (!environment) {
const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
const ciphertext = result.parsed[environmentKey];
if (!ciphertext) {
const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
throw err;
}
return { ciphertext, key };
}
function _vaultPath(options2) {
let possibleVaultPath = null;
if (options2 && options2.path && options2.path.length > 0) {
if (Array.isArray(options2.path)) {
for (const filepath of options2.path) {
if (fs9.existsSync(filepath)) {
possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
}
}
} else {
possibleVaultPath = options2.path.endsWith(".vault") ? options2.path : `${options2.path}.vault`;
}
} else {
possibleVaultPath = path16.resolve(process.cwd(), ".env.vault");
}
if (fs9.existsSync(possibleVaultPath)) {
return possibleVaultPath;
}
return null;
}
function _resolveHome(envPath) {
return envPath[0] === "~" ? path16.join(os2.homedir(), envPath.slice(1)) : envPath;
}
function _configVault(options2) {
_log("Loading env from encrypted .env.vault");
const parsed = DotenvModule._parseVault(options2);
let processEnv = process.env;
if (options2 && options2.processEnv != null) {
processEnv = options2.processEnv;
}
DotenvModule.populate(processEnv, parsed, options2);
return { parsed };
}
function configDotenv(options2) {
const dotenvPath = path16.resolve(process.cwd(), ".env");
let encoding = "utf8";
const debug2 = Boolean(options2 && options2.debug);
if (options2 && options2.encoding) {
encoding = options2.encoding;
} else {
if (debug2) {
_debug("No encoding is specified. UTF-8 is used by default");
}
}
let optionPaths = [dotenvPath];
if (options2 && options2.path) {
if (!Array.isArray(options2.path)) {
optionPaths = [_resolveHome(options2.path)];
} else {
optionPaths = [];
for (const filepath of options2.path) {
optionPaths.push(_resolveHome(filepath));
}
}
}
let lastError;
const parsedAll = {};
for (const path17 of optionPaths) {
try {
const parsed = DotenvModule.parse(fs9.readFileSync(path17, { encoding }));
DotenvModule.populate(parsedAll, parsed, options2);
} catch (e2) {
if (debug2) {
_debug(`Failed to load ${path17} ${e2.message}`);
}
lastError = e2;
}
}
let processEnv = process.env;
if (options2 && options2.processEnv != null) {
processEnv = options2.processEnv;
}
DotenvModule.populate(processEnv, parsedAll, options2);
if (lastError) {
return { parsed: parsedAll, error: lastError };
} else {
return { parsed: parsedAll };
}
}
function config3(options2) {
if (_dotenvKey(options2).length === 0) {
return DotenvModule.configDotenv(options2);
}
const vaultPath = _vaultPath(options2);
if (!vaultPath) {
_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
return DotenvModule.configDotenv(options2);
}
return DotenvModule._configVault(options2);
}
function decrypt(encrypted, keyStr) {
const key = Buffer.from(keyStr.slice(-64), "hex");
let ciphertext = Buffer.from(encrypted, "base64");
const nonce = ciphertext.subarray(0, 12);
const authTag = ciphertext.subarray(-16);
ciphertext = ciphertext.subarray(12, -16);
try {
const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
aesgcm.setAuthTag(authTag);
return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
} catch (error) {
const isRange = error instanceof RangeError;
const invalidKeyLength = error.message === "Invalid key length";
const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
if (isRange || invalidKeyLength) {
const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
err.code = "INVALID_DOTENV_KEY";
throw err;
} else if (decryptionFailed) {
const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
err.code = "DECRYPTION_FAILED";
throw err;
} else {
throw error;
}
}
}
function populate(processEnv, parsed, options2 = {}) {
const debug2 = Boolean(options2 && options2.debug);
const override = Boolean(options2 && options2.override);
if (typeof parsed !== "object") {
const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
err.code = "OBJECT_REQUIRED";
throw err;
}
for (const key of Object.keys(parsed)) {
if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
if (override === true) {
processEnv[key] = parsed[key];
}
if (debug2) {
if (override === true) {
_debug(`"${key}" is already defined and WAS overwritten`);
} else {
_debug(`"${key}" is already defined and was NOT overwritten`);
}
}
} else {
processEnv[key] = parsed[key];
}
}
}
var DotenvModule = {
configDotenv,
_configVault,
_parseVault,
config: config3,
decrypt,
parse: parse5,
populate
};
module2.exports.configDotenv = DotenvModule.configDotenv;
module2.exports._configVault = DotenvModule._configVault;
module2.exports._parseVault = DotenvModule._parseVault;
module2.exports.config = DotenvModule.config;
module2.exports.decrypt = DotenvModule.decrypt;
module2.exports.parse = DotenvModule.parse;
module2.exports.populate = DotenvModule.populate;
module2.exports = DotenvModule;
}
});
// node_modules/logform/format.js
var require_format = __commonJS({
"node_modules/logform/format.js"(exports2, module2) {
"use strict";
var InvalidFormatError = class _InvalidFormatError extends Error {
constructor(formatFn) {
super(`Format functions must be synchronous taking a two arguments: (info, opts)
Found: ${formatFn.toString().split("\n")[0]}
`);
Error.captureStackTrace(this, _InvalidFormatError);
}
};
module2.exports = (formatFn) => {
if (formatFn.length > 2) {
throw new InvalidFormatError(formatFn);
}
function Format(options2 = {}) {
this.options = options2;
}
Format.prototype.transform = formatFn;
function createFormatWrap(opts) {
return new Format(opts);
}
createFormatWrap.Format = Format;
return createFormatWrap;
};
}
});
// node_modules/@colors/colors/lib/styles.js
var require_styles = __commonJS({
"node_modules/@colors/colors/lib/styles.js"(exports2, module2) {
var styles3 = {};
module2["exports"] = styles3;
var codes = {
reset: [0, 0],
bold: [1, 22],
dim: [2, 22],
italic: [3, 23],
underline: [4, 24],
inverse: [7, 27],
hidden: [8, 28],
strikethrough: [9, 29],
black: [30, 39],
red: [31, 39],
green: [32, 39],
yellow: [33, 39],
blue: [34, 39],
magenta: [35, 39],
cyan: [36, 39],
white: [37, 39],
gray: [90, 39],
grey: [90, 39],
brightRed: [91, 39],
brightGreen: [92, 39],
brightYellow: [93, 39],
brightBlue: [94, 39],
brightMagenta: [95, 39],
brightCyan: [96, 39],
brightWhite: [97, 39],
bgBlack: [40, 49],
bgRed: [41, 49],
bgGreen: [42, 49],
bgYellow: [43, 49],
bgBlue: [44, 49],
bgMagenta: [45, 49],
bgCyan: [46, 49],
bgWhite: [47, 49],
bgGray: [100, 49],
bgGrey: [100, 49],
bgBrightRed: [101, 49],
bgBrightGreen: [102, 49],
bgBrightYellow: [103, 49],
bgBrightBlue: [104, 49],
bgBrightMagenta: [105, 49],
bgBrightCyan: [106, 49],
bgBrightWhite: [107, 49],
// legacy styles for colors pre v1.0.0
blackBG: [40, 49],
redBG: [41, 49],
greenBG: [42, 49],
yellowBG: [43, 49],
blueBG: [44, 49],
magentaBG: [45, 49],
cyanBG: [46, 49],
whiteBG: [47, 49]
};
Object.keys(codes).forEach(function(key) {
var val = codes[key];
var style = styles3[key] = [];
style.open = "\x1B[" + val[0] + "m";
style.close = "\x1B[" + val[1] + "m";
});
}
});
// node_modules/@colors/colors/lib/system/has-flag.js
var require_has_flag = __commonJS({
"node_modules/@colors/colors/lib/system/has-flag.js"(exports2, module2) {
"use strict";
module2.exports = function(flag, argv) {
argv = argv || process.argv || [];
var terminatorPos = argv.indexOf("--");
var prefix = /^-{1,2}/.test(flag) ? "" : "--";
var pos = argv.indexOf(prefix + flag);
return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
};
}
});
// node_modules/@colors/colors/lib/system/supports-colors.js
var require_supports_colors = __commonJS({
"node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module2) {
"use strict";
var os2 = __require("os");
var hasFlag2 = require_has_flag();
var env2 = process.env;
var forceColor = void 0;
if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
forceColor = false;
} else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
forceColor = true;
}
if ("FORCE_COLOR" in env2) {
forceColor = env2.FORCE_COLOR.length === 0 || parseInt(env2.FORCE_COLOR, 10) !== 0;
}
function translateLevel2(level) {
if (level === 0) {
return false;
}
return {
level,
hasBasic: true,
has256: level >= 2,
has16m: level >= 3
};
}
function supportsColor2(stream) {
if (forceColor === false) {
return 0;
}
if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
return 3;
}
if (hasFlag2("color=256")) {
return 2;
}
if (stream && !stream.isTTY && forceColor !== true) {
return 0;
}
var min = forceColor ? 1 : 0;
if (process.platform === "win32") {
var osRelease = os2.release().split(".");
if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
return Number(osRelease[2]) >= 14931 ? 3 : 2;
}
return 1;
}
if ("CI" in env2) {
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign) {
return sign in env2;
}) || env2.CI_NAME === "codeship") {
return 1;
}
return min;
}
if ("TEAMCITY_VERSION" in env2) {
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
}
if ("TERM_PROGRAM" in env2) {
var version = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
switch (env2.TERM_PROGRAM) {
case "iTerm.app":
return version >= 3 ? 3 : 2;
case "Hyper":
return 3;
case "Apple_Terminal":
return 2;
}
}
if (/-256(color)?$/i.test(env2.TERM)) {
return 2;
}
if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
return 1;
}
if ("COLORTERM" in env2) {
return 1;
}
if (env2.TERM === "dumb") {
return min;
}
return min;
}
function getSupportLevel(stream) {
var level = supportsColor2(stream);
return translateLevel2(level);
}
module2.exports = {
supportsColor: getSupportLevel,
stdout: getSupportLevel(process.stdout),
stderr: getSupportLevel(process.stderr)
};
}
});
// node_modules/@colors/colors/lib/custom/trap.js
var require_trap = __commonJS({
"node_modules/@colors/colors/lib/custom/trap.js"(exports2, module2) {
module2["exports"] = function runTheTrap(text3, options2) {
var result = "";
text3 = text3 || "Run the trap, drop the bass";
text3 = text3.split("");
var trap = {
a: ["@", "\u0104", "\u023A", "\u0245", "\u0394", "\u039B", "\u0414"],
b: ["\xDF", "\u0181", "\u0243", "\u026E", "\u03B2", "\u0E3F"],
c: ["\xA9", "\u023B", "\u03FE"],
d: ["\xD0", "\u018A", "\u0500", "\u0501", "\u0502", "\u0503"],
e: [
"\xCB",
"\u0115",
"\u018E",
"\u0258",
"\u03A3",
"\u03BE",
"\u04BC",
"\u0A6C"
],
f: ["\u04FA"],
g: ["\u0262"],
h: ["\u0126", "\u0195", "\u04A2", "\u04BA", "\u04C7", "\u050A"],
i: ["\u0F0F"],
j: ["\u0134"],
k: ["\u0138", "\u04A0", "\u04C3", "\u051E"],
l: ["\u0139"],
m: ["\u028D", "\u04CD", "\u04CE", "\u0520", "\u0521", "\u0D69"],
n: ["\xD1", "\u014B", "\u019D", "\u0376", "\u03A0", "\u048A"],
o: [
"\xD8",
"\xF5",
"\xF8",
"\u01FE",
"\u0298",
"\u047A",
"\u05DD",
"\u06DD",
"\u0E4F"
],
p: ["\u01F7", "\u048E"],
q: ["\u09CD"],
r: ["\xAE", "\u01A6", "\u0210", "\u024C", "\u0280", "\u042F"],
s: ["\xA7", "\u03DE", "\u03DF", "\u03E8"],
t: ["\u0141", "\u0166", "\u0373"],
u: ["\u01B1", "\u054D"],
v: ["\u05D8"],
w: ["\u0428", "\u0460", "\u047C", "\u0D70"],
x: ["\u04B2", "\u04FE", "\u04FC", "\u04FD"],
y: ["\xA5", "\u04B0", "\u04CB"],
z: ["\u01B5", "\u0240"]
};
text3.forEach(function(c2) {
c2 = c2.toLowerCase();
var chars = trap[c2] || [" "];
var rand = Math.floor(Math.random() * chars.length);
if (typeof trap[c2] !== "undefined") {
result += trap[c2][rand];
} else {
result += c2;
}
});
return result;
};
}
});
// node_modules/@colors/colors/lib/custom/zalgo.js
var require_zalgo = __commonJS({
"node_modules/@colors/colors/lib/custom/zalgo.js"(exports2, module2) {
module2["exports"] = function zalgo(text3, options2) {
text3 = text3 || " he is here ";
var soul = {
"up": [
"\u030D",
"\u030E",
"\u0304",
"\u0305",
"\u033F",
"\u0311",
"\u0306",
"\u0310",
"\u0352",
"\u0357",
"\u0351",
"\u0307",
"\u0308",
"\u030A",
"\u0342",
"\u0313",
"\u0308",
"\u034A",
"\u034B",
"\u034C",
"\u0303",
"\u0302",
"\u030C",
"\u0350",
"\u0300",
"\u0301",
"\u030B",
"\u030F",
"\u0312",
"\u0313",
"\u0314",
"\u033D",
"\u0309",
"\u0363",
"\u0364",
"\u0365",
"\u0366",
"\u0367",
"\u0368",
"\u0369",
"\u036A",
"\u036B",
"\u036C",
"\u036D",
"\u036E",
"\u036F",
"\u033E",
"\u035B",
"\u0346",
"\u031A"
],
"down": [
"\u0316",
"\u0317",
"\u0318",
"\u0319",
"\u031C",
"\u031D",
"\u031E",
"\u031F",
"\u0320",
"\u0324",
"\u0325",
"\u0326",
"\u0329",
"\u032A",
"\u032B",
"\u032C",
"\u032D",
"\u032E",
"\u032F",
"\u0330",
"\u0331",
"\u0332",
"\u0333",
"\u0339",
"\u033A",
"\u033B",
"\u033C",
"\u0345",
"\u0347",
"\u0348",
"\u0349",
"\u034D",
"\u034E",
"\u0353",
"\u0354",
"\u0355",
"\u0356",
"\u0359",
"\u035A",
"\u0323"
],
"mid": [
"\u0315",
"\u031B",
"\u0300",
"\u0301",
"\u0358",
"\u0321",
"\u0322",
"\u0327",
"\u0328",
"\u0334",
"\u0335",
"\u0336",
"\u035C",
"\u035D",
"\u035E",
"\u035F",
"\u0360",
"\u0362",
"\u0338",
"\u0337",
"\u0361",
" \u0489"
]
};
var all2 = [].concat(soul.up, soul.down, soul.mid);
function randomNumber(range) {
var r2 = Math.floor(Math.random() * range);
return r2;
}
function isChar(character) {
var bool2 = false;
all2.filter(function(i2) {
bool2 = i2 === character;
});
return bool2;
}
function heComes(text4, options3) {
var result = "";
var counts;
var l2;
options3 = options3 || {};
options3["up"] = typeof options3["up"] !== "undefined" ? options3["up"] : true;
options3["mid"] = typeof options3["mid"] !== "undefined" ? options3["mid"] : true;
options3["down"] = typeof options3["down"] !== "undefined" ? options3["down"] : true;
options3["size"] = typeof options3["size"] !== "undefined" ? options3["size"] : "maxi";
text4 = text4.split("");
for (l2 in text4) {
if (isChar(l2)) {
continue;
}
result = result + text4[l2];
counts = { "up": 0, "down": 0, "mid": 0 };
switch (options3.size) {
case "mini":
counts.up = randomNumber(8);
counts.mid = randomNumber(2);
counts.down = randomNumber(8);
break;
case "maxi":
counts.up = randomNumber(16) + 3;
counts.mid = randomNumber(4) + 1;
counts.down = randomNumber(64) + 3;
break;
default:
counts.up = randomNumber(8) + 1;
counts.mid = randomNumber(6) / 2;
counts.down = randomNumber(8) + 1;
break;
}
var arr = ["up", "mid", "down"];
for (var d2 in arr) {
var index2 = arr[d2];
for (var i2 = 0; i2 <= counts[index2]; i2++) {
if (options3[index2]) {
result = result + soul[index2][randomNumber(soul[index2].length)];
}
}
}
}
return result;
}
return heComes(text3, options2);
};
}
});
// node_modules/@colors/colors/lib/maps/america.js
var require_america = __commonJS({
"node_modules/@colors/colors/lib/maps/america.js"(exports2, module2) {
module2["exports"] = function(colors) {
return function(letter, i2, exploded) {
if (letter === " ")
return letter;
switch (i2 % 3) {
case 0:
return colors.red(letter);
case 1:
return colors.white(letter);
case 2:
return colors.blue(letter);
}
};
};
}
});
// node_modules/@colors/colors/lib/maps/zebra.js
var require_zebra = __commonJS({
"node_modules/@colors/colors/lib/maps/zebra.js"(exports2, module2) {
module2["exports"] = function(colors) {
return function(letter, i2, exploded) {
return i2 % 2 === 0 ? letter : colors.inverse(letter);
};
};
}
});
// node_modules/@colors/colors/lib/maps/rainbow.js
var require_rainbow = __commonJS({
"node_modules/@colors/colors/lib/maps/rainbow.js"(exports2, module2) {
module2["exports"] = function(colors) {
var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
return function(letter, i2, exploded) {
if (letter === " ") {
return letter;
} else {
return colors[rainbowColors[i2++ % rainbowColors.length]](letter);
}
};
};
}
});
// node_modules/@colors/colors/lib/maps/random.js
var require_random = __commonJS({
"node_modules/@colors/colors/lib/maps/random.js"(exports2, module2) {
module2["exports"] = function(colors) {
var available = [
"underline",
"inverse",
"grey",
"yellow",
"red",
"green",
"blue",
"white",
"cyan",
"magenta",
"brightYellow",
"brightRed",
"brightGreen",
"brightBlue",
"brightWhite",
"brightCyan",
"brightMagenta"
];
return function(letter, i2, exploded) {
return letter === " " ? letter : colors[available[Math.round(Math.random() * (available.length - 2))]](letter);
};
};
}
});
// node_modules/@colors/colors/lib/colors.js
var require_colors = __commonJS({
"node_modules/@colors/colors/lib/colors.js"(exports2, module2) {
var colors = {};
module2["exports"] = colors;
colors.themes = {};
var util = __require("util");
var ansiStyles2 = colors.styles = require_styles();
var defineProps = Object.defineProperties;
var newLineRegex = new RegExp(/[\r\n]+/g);
colors.supportsColor = require_supports_colors().supportsColor;
if (typeof colors.enabled === "undefined") {
colors.enabled = colors.supportsColor() !== false;
}
colors.enable = function() {
colors.enabled = true;
};
colors.disable = function() {
colors.enabled = false;
};
colors.stripColors = colors.strip = function(str2) {
return ("" + str2).replace(/\x1B\[\d+m/g, "");
};
var stylize = colors.stylize = function stylize2(str2, style) {
if (!colors.enabled) {
return str2 + "";
}
var styleMap = ansiStyles2[style];
if (!styleMap && style in colors) {
return colors[style](str2);
}
return styleMap.open + str2 + styleMap.close;
};
var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
var escapeStringRegexp = function(str2) {
if (typeof str2 !== "string") {
throw new TypeError("Expected a string");
}
return str2.replace(matchOperatorsRe, "\\$&");
};
function build(_styles) {
var builder = function builder2() {
return applyStyle2.apply(builder2, arguments);
};
builder._styles = _styles;
builder.__proto__ = proto2;
return builder;
}
var styles3 = function() {
var ret = {};
ansiStyles2.grey = ansiStyles2.gray;
Object.keys(ansiStyles2).forEach(function(key) {
ansiStyles2[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles2[key].close), "g");
ret[key] = {
get: function() {
return build(this._styles.concat(key));
}
};
});
return ret;
}();
var proto2 = defineProps(function colors2() {
}, styles3);
function applyStyle2() {
var args = Array.prototype.slice.call(arguments);
var str2 = args.map(function(arg) {
if (arg != null && arg.constructor === String) {
return arg;
} else {
return util.inspect(arg);
}
}).join(" ");
if (!colors.enabled || !str2) {
return str2;
}
var newLinesPresent = str2.indexOf("\n") != -1;
var nestedStyles = this._styles;
var i2 = nestedStyles.length;
while (i2--) {
var code = ansiStyles2[nestedStyles[i2]];
str2 = code.open + str2.replace(code.closeRe, code.open) + code.close;
if (newLinesPresent) {
str2 = str2.replace(newLineRegex, function(match2) {
return code.close + match2 + code.open;
});
}
}
return str2;
}
colors.setTheme = function(theme) {
if (typeof theme === "string") {
console.log("colors.setTheme now only accepts an object, not a string. If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file. The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
return;
}
for (var style in theme) {
(function(style2) {
colors[style2] = function(str2) {
if (typeof theme[style2] === "object") {
var out = str2;
for (var i2 in theme[style2]) {
out = colors[theme[style2][i2]](out);
}
return out;
}
return colors[theme[style2]](str2);
};
})(style);
}
};
function init() {
var ret = {};
Object.keys(styles3).forEach(function(name) {
ret[name] = {
get: function() {
return build([name]);
}
};
});
return ret;
}
var sequencer = function sequencer2(map3, str2) {
var exploded = str2.split("");
exploded = exploded.map(map3);
return exploded.join("");
};
colors.trap = require_trap();
colors.zalgo = require_zalgo();
colors.maps = {};
colors.maps.america = require_america()(colors);
colors.maps.zebra = require_zebra()(colors);
colors.maps.rainbow = require_rainbow()(colors);
colors.maps.random = require_random()(colors);
for (map2 in colors.maps) {
(function(map3) {
colors[map3] = function(str2) {
return sequencer(colors.maps[map3], str2);
};
})(map2);
}
var map2;
defineProps(colors, init());
}
});
// node_modules/@colors/colors/safe.js
var require_safe = __commonJS({
"node_modules/@colors/colors/safe.js"(exports2, module2) {
var colors = require_colors();
module2["exports"] = colors;
}
});
// node_modules/triple-beam/config/cli.js
var require_cli = __commonJS({
"node_modules/triple-beam/config/cli.js"(exports2) {
"use strict";
exports2.levels = {
error: 0,
warn: 1,
help: 2,
data: 3,
info: 4,
debug: 5,
prompt: 6,
verbose: 7,
input: 8,
silly: 9
};
exports2.colors = {
error: "red",
warn: "yellow",
help: "cyan",
data: "grey",
info: "green",
debug: "blue",
prompt: "grey",
verbose: "cyan",
input: "grey",
silly: "magenta"
};
}
});
// node_modules/triple-beam/config/npm.js
var require_npm = __commonJS({
"node_modules/triple-beam/config/npm.js"(exports2) {
"use strict";
exports2.levels = {
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
};
exports2.colors = {
error: "red",
warn: "yellow",
info: "green",
http: "green",
verbose: "cyan",
debug: "blue",
silly: "magenta"
};
}
});
// node_modules/triple-beam/config/syslog.js
var require_syslog = __commonJS({
"node_modules/triple-beam/config/syslog.js"(exports2) {
"use strict";
exports2.levels = {
emerg: 0,
alert: 1,
crit: 2,
error: 3,
warning: 4,
notice: 5,
info: 6,
debug: 7
};
exports2.colors = {
emerg: "red",
alert: "yellow",
crit: "red",
error: "red",
warning: "red",
notice: "yellow",
info: "green",
debug: "blue"
};
}
});
// node_modules/triple-beam/config/index.js
var require_config = __commonJS({
"node_modules/triple-beam/config/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "cli", {
value: require_cli()
});
Object.defineProperty(exports2, "npm", {
value: require_npm()
});
Object.defineProperty(exports2, "syslog", {
value: require_syslog()
});
}
});
// node_modules/triple-beam/index.js
var require_triple_beam = __commonJS({
"node_modules/triple-beam/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "LEVEL", {
value: Symbol.for("level")
});
Object.defineProperty(exports2, "MESSAGE", {
value: Symbol.for("message")
});
Object.defineProperty(exports2, "SPLAT", {
value: Symbol.for("splat")
});
Object.defineProperty(exports2, "configs", {
value: require_config()
});
}
});
// node_modules/logform/colorize.js
var require_colorize = __commonJS({
"node_modules/logform/colorize.js"(exports2, module2) {
"use strict";
var colors = require_safe();
var { LEVEL, MESSAGE: MESSAGE2 } = require_triple_beam();
colors.enabled = true;
var hasSpace = /\s+/;
var Colorizer = class _Colorizer {
constructor(opts = {}) {
if (opts.colors) {
this.addColors(opts.colors);
}
this.options = opts;
}
/*
* Adds the colors Object to the set of allColors
* known by the Colorizer
*
* @param {Object} colors Set of color mappings to add.
*/
static addColors(clrs) {
const nextColors = Object.keys(clrs).reduce((acc, level) => {
acc[level] = hasSpace.test(clrs[level]) ? clrs[level].split(hasSpace) : clrs[level];
return acc;
}, {});
_Colorizer.allColors = Object.assign({}, _Colorizer.allColors || {}, nextColors);
return _Colorizer.allColors;
}
/*
* Adds the colors Object to the set of allColors
* known by the Colorizer
*
* @param {Object} colors Set of color mappings to add.
*/
addColors(clrs) {
return _Colorizer.addColors(clrs);
}
/*
* function colorize (lookup, level, message)
* Performs multi-step colorization using @colors/colors/safe
*/
colorize(lookup2, level, message) {
if (typeof message === "undefined") {
message = level;
}
if (!Array.isArray(_Colorizer.allColors[lookup2])) {
return colors[_Colorizer.allColors[lookup2]](message);
}
for (let i2 = 0, len = _Colorizer.allColors[lookup2].length; i2 < len; i2++) {
message = colors[_Colorizer.allColors[lookup2][i2]](message);
}
return message;
}
/*
* function transform (info, opts)
* Attempts to colorize the { level, message } of the given
* `logform` info object.
*/
transform(info, opts) {
if (opts.all && typeof info[MESSAGE2] === "string") {
info[MESSAGE2] = this.colorize(info[LEVEL], info.level, info[MESSAGE2]);
}
if (opts.level || opts.all || !opts.message) {
info.level = this.colorize(info[LEVEL], info.level);
}
if (opts.all || opts.message) {
info.message = this.colorize(info[LEVEL], info.level, info.message);
}
return info;
}
};
module2.exports = (opts) => new Colorizer(opts);
module2.exports.Colorizer = module2.exports.Format = Colorizer;
}
});
// node_modules/logform/levels.js
var require_levels = __commonJS({
"node_modules/logform/levels.js"(exports2, module2) {
"use strict";
var { Colorizer } = require_colorize();
module2.exports = (config3) => {
Colorizer.addColors(config3.colors || config3);
return config3;
};
}
});
// node_modules/logform/align.js
var require_align = __commonJS({
"node_modules/logform/align.js"(exports2, module2) {
"use strict";
var format = require_format();
module2.exports = format((info) => {
info.message = ` ${info.message}`;
return info;
});
}
});
// node_modules/logform/errors.js
var require_errors = __commonJS({
"node_modules/logform/errors.js"(exports2, module2) {
"use strict";
var format = require_format();
var { LEVEL, MESSAGE: MESSAGE2 } = require_triple_beam();
module2.exports = format((einfo, { stack, cause }) => {
if (einfo instanceof Error) {
const info = Object.assign({}, einfo, {
level: einfo.level,
[LEVEL]: einfo[LEVEL] || einfo.level,
message: einfo.message,
[MESSAGE2]: einfo[MESSAGE2] || einfo.message
});
if (stack)
info.stack = einfo.stack;
if (cause)
info.cause = einfo.cause;
return info;
}
if (!(einfo.message instanceof Error))
return einfo;
const err = einfo.message;
Object.assign(einfo, err);
einfo.message = err.message;
einfo[MESSAGE2] = err.message;
if (stack)
einfo.stack = err.stack;
if (cause)
einfo.cause = err.cause;
return einfo;
});
}
});
// node_modules/logform/pad-levels.js
var require_pad_levels = __commonJS({
"node_modules/logform/pad-levels.js"(exports2, module2) {
"use strict";
var { configs, LEVEL, MESSAGE: MESSAGE2 } = require_triple_beam();
var Padder = class _Padder {
constructor(opts = { levels: configs.npm.levels }) {
this.paddings = _Padder.paddingForLevels(opts.levels, opts.filler);
this.options = opts;
}
/**
* Returns the maximum length of keys in the specified `levels` Object.
* @param {Object} levels Set of all levels to calculate longest level against.
* @returns {Number} Maximum length of the longest level string.
*/
static getLongestLevel(levels) {
const lvls = Object.keys(levels).map((level) => level.length);
return Math.max(...lvls);
}
/**
* Returns the padding for the specified `level` assuming that the
* maximum length of all levels it's associated with is `maxLength`.
* @param {String} level Level to calculate padding for.
* @param {String} filler Repeatable text to use for padding.
* @param {Number} maxLength Length of the longest level
* @returns {String} Padding string for the `level`
*/
static paddingForLevel(level, filler, maxLength) {
const targetLen = maxLength + 1 - level.length;
const rep = Math.floor(targetLen / filler.length);
const padding = `${filler}${filler.repeat(rep)}`;
return padding.slice(0, targetLen);
}
/**
* Returns an object with the string paddings for the given `levels`
* using the specified `filler`.
* @param {Object} levels Set of all levels to calculate padding for.
* @param {String} filler Repeatable text to use for padding.
* @returns {Object} Mapping of level to desired padding.
*/
static paddingForLevels(levels, filler = " ") {
const maxLength = _Padder.getLongestLevel(levels);
return Object.keys(levels).reduce((acc, level) => {
acc[level] = _Padder.paddingForLevel(level, filler, maxLength);
return acc;
}, {});
}
/**
* Prepends the padding onto the `message` based on the `LEVEL` of
* the `info`. This is based on the behavior of `winston@2` which also
* prepended the level onto the message.
*
* See: https://github.com/winstonjs/winston/blob/2.x/lib/winston/logger.js#L198-L201
*
* @param {Info} info Logform info object
* @param {Object} opts Options passed along to this instance.
* @returns {Info} Modified logform info object.
*/
transform(info, opts) {
info.message = `${this.paddings[info[LEVEL]]}${info.message}`;
if (info[MESSAGE2]) {
info[MESSAGE2] = `${this.paddings[info[LEVEL]]}${info[MESSAGE2]}`;
}
return info;
}
};
module2.exports = (opts) => new Padder(opts);
module2.exports.Padder = module2.exports.Format = Padder;
}
});
// node_modules/logform/cli.js
var require_cli2 = __commonJS({
"node_modules/logform/cli.js"(exports2, module2) {
"use strict";
var { Colorizer } = require_colorize();
var { Padder } = require_pad_levels();
var { configs, MESSAGE: MESSAGE2 } = require_triple_beam();
var CliFormat = class {
constructor(opts = {}) {
if (!opts.levels) {
opts.levels = configs.cli.levels;
}
this.colorizer = new Colorizer(opts);
this.padder = new Padder(opts);
this.options = opts;
}
/*
* function transform (info, opts)
* Attempts to both:
* 1. Pad the { level }
* 2. Colorize the { level, message }
* of the given `logform` info object depending on the `opts`.
*/
transform(info, opts) {
this.colorizer.transform(
this.padder.transform(info, opts),
opts
);
info[MESSAGE2] = `${info.level}:${info.message}`;
return info;
}
};
module2.exports = (opts) => new CliFormat(opts);
module2.exports.Format = CliFormat;
}
});
// node_modules/logform/combine.js
var require_combine = __commonJS({
"node_modules/logform/combine.js"(exports2, module2) {
"use strict";
var format = require_format();
function cascade(formats) {
if (!formats.every(isValidFormat)) {
return;
}
return (info) => {
let obj = info;
for (let i2 = 0; i2 < formats.length; i2++) {
obj = formats[i2].transform(obj, formats[i2].options);
if (!obj) {
return false;
}
}
return obj;
};
}
function isValidFormat(fmt) {
if (typeof fmt.transform !== "function") {
throw new Error([
"No transform function found on format. Did you create a format instance?",
"const myFormat = format(formatFn);",
"const instance = myFormat();"
].join("\n"));
}
return true;
}
module2.exports = (...formats) => {
const combinedFormat = format(cascade(formats));
const instance = combinedFormat();
instance.Format = combinedFormat.Format;
return instance;
};
module2.exports.cascade = cascade;
}
});
// node_modules/safe-stable-stringify/index.js
var require_safe_stable_stringify = __commonJS({
"node_modules/safe-stable-stringify/index.js"(exports2, module2) {
"use strict";
var { hasOwnProperty: hasOwnProperty2 } = Object.prototype;
var stringify = configure2();
stringify.configure = configure2;
stringify.stringify = stringify;
stringify.default = stringify;
exports2.stringify = stringify;
exports2.configure = configure2;
module2.exports = stringify;
var strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
function strEscape(str2) {
if (str2.length < 5e3 && !strEscapeSequencesRegExp.test(str2)) {
return `"${str2}"`;
}
return JSON.stringify(str2);
}
function sort(array, comparator) {
if (array.length > 200 || comparator) {
return array.sort(comparator);
}
for (let i2 = 1; i2 < array.length; i2++) {
const currentValue = array[i2];
let position2 = i2;
while (position2 !== 0 && array[position2 - 1] > currentValue) {
array[position2] = array[position2 - 1];
position2--;
}
array[position2] = currentValue;
}
return array;
}
var typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
Object.getPrototypeOf(
Object.getPrototypeOf(
new Int8Array()
)
),
Symbol.toStringTag
).get;
function isTypedArrayWithEntries(value) {
return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
}
function stringifyTypedArray(array, separator, maximumBreadth) {
if (array.length < maximumBreadth) {
maximumBreadth = array.length;
}
const whitespace = separator === "," ? "" : " ";
let res = `"0":${whitespace}${array[0]}`;
for (let i2 = 1; i2 < maximumBreadth; i2++) {
res += `${separator}"${i2}":${whitespace}${array[i2]}`;
}
return res;
}
function getCircularValueOption(options2) {
if (hasOwnProperty2.call(options2, "circularValue")) {
const circularValue = options2.circularValue;
if (typeof circularValue === "string") {
return `"${circularValue}"`;
}
if (circularValue == null) {
return circularValue;
}
if (circularValue === Error || circularValue === TypeError) {
return {
toString() {
throw new TypeError("Converting circular structure to JSON");
}
};
}
throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
}
return '"[Circular]"';
}
function getDeterministicOption(options2) {
let value;
if (hasOwnProperty2.call(options2, "deterministic")) {
value = options2.deterministic;
if (typeof value !== "boolean" && typeof value !== "function") {
throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
}
}
return value === void 0 ? true : value;
}
function getBooleanOption(options2, key) {
let value;
if (hasOwnProperty2.call(options2, key)) {
value = options2[key];
if (typeof value !== "boolean") {
throw new TypeError(`The "${key}" argument must be of type boolean`);
}
}
return value === void 0 ? true : value;
}
function getPositiveIntegerOption(options2, key) {
let value;
if (hasOwnProperty2.call(options2, key)) {
value = options2[key];
if (typeof value !== "number") {
throw new TypeError(`The "${key}" argument must be of type number`);
}
if (!Number.isInteger(value)) {
throw new TypeError(`The "${key}" argument must be an integer`);
}
if (value < 1) {
throw new RangeError(`The "${key}" argument must be >= 1`);