llmxml
Version:
Convert between markdown and LLM-friendly pseudo-XML
1,558 lines (1,527 loc) • 905 kB
JavaScript
'use strict';
var default2 = require('path');
var default3 = require('process');
var url = require('url');
var events$1 = require('events');
var fs = require('fs');
var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
var default2__default = /*#__PURE__*/_interopDefault(default2);
var default3__default = /*#__PURE__*/_interopDefault(default3);
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__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" 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.
__defProp(target, "default", { value: mod, enumerable: true }) ,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/extend/index.js
var require_extend = __commonJS({
"node_modules/extend/index.js"(exports2, module2) {
var hasOwn = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var defineProperty = Object.defineProperty;
var gOPD = Object.getOwnPropertyDescriptor;
var isArray = function isArray2(arr) {
if (typeof Array.isArray === "function") {
return Array.isArray(arr);
}
return toStr.call(arr) === "[object Array]";
};
var isPlainObject2 = function isPlainObject3(obj) {
if (!obj || toStr.call(obj) !== "[object Object]") {
return false;
}
var hasOwnConstructor = hasOwn.call(obj, "constructor");
var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
return false;
}
var key;
for (key in obj) {
}
return typeof key === "undefined" || hasOwn.call(obj, key);
};
var setProperty = function setProperty2(target, options2) {
if (defineProperty && options2.name === "__proto__") {
defineProperty(target, options2.name, {
enumerable: true,
configurable: true,
value: options2.newValue,
writable: true
});
} else {
target[options2.name] = options2.newValue;
}
};
var getProperty = function getProperty2(obj, name) {
if (name === "__proto__") {
if (!hasOwn.call(obj, name)) {
return void 0;
} else if (gOPD) {
return gOPD(obj, name).value;
}
}
return obj[name];
};
module2.exports = function extend2() {
var options2, name, src, copy, copyIsArray, clone;
var target = arguments[0];
var i = 1;
var length = arguments.length;
var deep = false;
if (typeof target === "boolean") {
deep = target;
target = arguments[1] || {};
i = 2;
}
if (target == null || typeof target !== "object" && typeof target !== "function") {
target = {};
}
for (; i < length; ++i) {
options2 = arguments[i];
if (options2 != null) {
for (name in options2) {
src = getProperty(target, name);
copy = getProperty(options2, name);
if (target !== copy) {
if (deep && copy && (isPlainObject2(copy) || (copyIsArray = isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && isArray(src) ? src : [];
} else {
clone = src && isPlainObject2(src) ? src : {};
}
setProperty(target, { name, newValue: extend2(deep, clone, copy) });
} else if (typeof copy !== "undefined") {
setProperty(target, { name, newValue: copy });
}
}
}
}
}
return target;
};
}
});
// node_modules/logform/format.js
var require_format = __commonJS({
"node_modules/logform/format.js"(exports2, module2) {
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 styles = {};
module2["exports"] = styles;
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 = styles[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) {
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) {
var os = __require("os");
var hasFlag = require_has_flag();
var env = process.env;
var forceColor = void 0;
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
forceColor = false;
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
forceColor = true;
}
if ("FORCE_COLOR" in env) {
forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
}
function translateLevel(level) {
if (level === 0) {
return false;
}
return {
level,
hasBasic: true,
has256: level >= 2,
has16m: level >= 3
};
}
function supportsColor(stream) {
if (forceColor === false) {
return 0;
}
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
return 3;
}
if (hasFlag("color=256")) {
return 2;
}
if (stream && !stream.isTTY && forceColor !== true) {
return 0;
}
var min = forceColor ? 1 : 0;
if (process.platform === "win32") {
var osRelease = os.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 env) {
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign) {
return sign in env;
}) || env.CI_NAME === "codeship") {
return 1;
}
return min;
}
if ("TEAMCITY_VERSION" in env) {
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
}
if ("TERM_PROGRAM" in env) {
var version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
switch (env.TERM_PROGRAM) {
case "iTerm.app":
return version >= 3 ? 3 : 2;
case "Hyper":
return 3;
case "Apple_Terminal":
return 2;
}
}
if (/-256(color)?$/i.test(env.TERM)) {
return 2;
}
if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
return 1;
}
if ("COLORTERM" in env) {
return 1;
}
if (env.TERM === "dumb") {
return min;
}
return min;
}
function getSupportLevel(stream) {
var level = supportsColor(stream);
return translateLevel(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(c) {
c = c.toLowerCase();
var chars = trap[c] || [" "];
var rand = Math.floor(Math.random() * chars.length);
if (typeof trap[c] !== "undefined") {
result += trap[c][rand];
} else {
result += c;
}
});
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 r = Math.floor(Math.random() * range);
return r;
}
function isChar(character) {
var bool = false;
all2.filter(function(i) {
bool = i === character;
});
return bool;
}
function heComes(text4, options3) {
var result = "";
var counts;
var l;
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 (l in text4) {
if (isChar(l)) {
continue;
}
result = result + text4[l];
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 d in arr) {
var index2 = arr[d];
for (var i = 0; i <= counts[index2]; i++) {
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, i, exploded) {
if (letter === " ") return letter;
switch (i % 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, i, exploded) {
return i % 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, i, exploded) {
if (letter === " ") {
return letter;
} else {
return colors[rainbowColors[i++ % 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, i, 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 ansiStyles = 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(str) {
return ("" + str).replace(/\x1B\[\d+m/g, "");
};
colors.stylize = function stylize2(str, style) {
if (!colors.enabled) {
return str + "";
}
var styleMap = ansiStyles[style];
if (!styleMap && style in colors) {
return colors[style](str);
}
return styleMap.open + str + styleMap.close;
};
var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
var escapeStringRegexp = function(str) {
if (typeof str !== "string") {
throw new TypeError("Expected a string");
}
return str.replace(matchOperatorsRe, "\\$&");
};
function build(_styles) {
var builder = function builder2() {
return applyStyle.apply(builder2, arguments);
};
builder._styles = _styles;
builder.__proto__ = proto;
return builder;
}
var styles = function() {
var ret = {};
ansiStyles.grey = ansiStyles.gray;
Object.keys(ansiStyles).forEach(function(key) {
ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
ret[key] = {
get: function() {
return build(this._styles.concat(key));
}
};
});
return ret;
}();
var proto = defineProps(function colors2() {
}, styles);
function applyStyle() {
var args = Array.prototype.slice.call(arguments);
var str = args.map(function(arg) {
if (arg != null && arg.constructor === String) {
return arg;
} else {
return util.inspect(arg);
}
}).join(" ");
if (!colors.enabled || !str) {
return str;
}
var newLinesPresent = str.indexOf("\n") != -1;
var nestedStyles = this._styles;
var i = nestedStyles.length;
while (i--) {
var code = ansiStyles[nestedStyles[i]];
str = code.open + str.replace(code.closeRe, code.open) + code.close;
if (newLinesPresent) {
str = str.replace(newLineRegex, function(match) {
return code.close + match + code.open;
});
}
}
return str;
}
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(str) {
if (typeof theme[style2] === "object") {
var out = str;
for (var i in theme[style2]) {
out = colors[theme[style2][i]](out);
}
return out;
}
return colors[theme[style2]](str);
};
})(style);
}
};
function init() {
var ret = {};
Object.keys(styles).forEach(function(name) {
ret[name] = {
get: function() {
return build([name]);
}
};
});
return ret;
}
var sequencer = function sequencer2(map2, str) {
var exploded = str.split("");
exploded = exploded.map(map2);
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 (map in colors.maps) {
(function(map2) {
colors[map2] = function(str) {
return sequencer(colors.maps[map2], str);
};
})(map);
}
var map;
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) {
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) {
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) {
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) {
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) {
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) {
var colors = require_safe();
var { LEVEL, MESSAGE } = 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(lookup, level, message) {
if (typeof message === "undefined") {
message = level;
}
if (!Array.isArray(_Colorizer.allColors[lookup])) {
return colors[_Colorizer.allColors[lookup]](message);
}
for (let i = 0, len = _Colorizer.allColors[lookup].length; i < len; i++) {
message = colors[_Colorizer.allColors[lookup][i]](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[MESSAGE] === "string") {
info[MESSAGE] = this.colorize(info[LEVEL], info.level, info[MESSAGE]);
}
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) {
var { Colorizer } = require_colorize();
module2.exports = (config) => {
Colorizer.addColors(config.colors || config);
return config;
};
}
});
// node_modules/logform/align.js
var require_align = __commonJS({
"node_modules/logform/align.js"(exports2, module2) {
var format2 = require_format();
module2.exports = format2((info) => {
info.message = ` ${info.message}`;
return info;
});
}
});
// node_modules/logform/errors.js
var require_errors = __commonJS({
"node_modules/logform/errors.js"(exports2, module2) {
var format2 = require_format();
var { LEVEL, MESSAGE } = require_triple_beam();
module2.exports = format2((einfo, { stack, cause }) => {
if (einfo instanceof Error) {
const info = Object.assign({}, einfo, {
level: einfo.level,
[LEVEL]: einfo[LEVEL] || einfo.level,
message: einfo.message,
[MESSAGE]: einfo[MESSAGE] || 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[MESSAGE] = 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) {
var { configs, LEVEL, MESSAGE } = 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[MESSAGE]) {
info[MESSAGE] = `${this.paddings[info[LEVEL]]}${info[MESSAGE]}`;
}
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) {
var { Colorizer } = require_colorize();
var { Padder } = require_pad_levels();
var { configs, MESSAGE } = 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[MESSAGE] = `${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) {
var format2 = require_format();
function cascade(formats) {
if (!formats.every(isValidFormat)) {
return;
}
return (info) => {
let obj = info;
for (let i = 0; i < formats.length; i++) {
obj = formats[i].transform(obj, formats[i].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 = format2(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) {
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(str) {
if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
return `"${str}"`;
}
return JSON.stringify(str);
}
function sort(array, comparator) {
if (array.length > 200 || comparator) {
return array.sort(comparator);
}
for (let i = 1; i < array.length; i++) {
const currentValue = array[i];
let position2 = i;
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 i = 1; i < maximumBreadth; i++) {
res += `${separator}"${i}":${whitespace}${array[i]}`;
}
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`);
}
}
return value === void 0 ? Infinity : value;
}
function getItemCount(number) {
if (number === 1) {
return "1 item";
}
return `${number} items`;
}
function getUniqueReplacerSet(replacerArray) {
const replacerSet = /* @__PURE__ */ new Set();
for (const value of replacerArray) {
if (typeof value === "string" || typeof value === "number") {
replacerSet.add(String(value));
}
}
return replacerSet;
}
function getStrictOption(options2) {
if (hasOwnProperty2.call(options2, "strict")) {
const value = options2.strict;
if (typeof value !== "boolean") {
throw new TypeError('The "strict" argument must be of type boolean');
}
if (value) {
return (value2) => {
let message = `Object can not safely be stringified. Received type ${typeof value2}`;
if (typeof value2 !== "function") message += ` (${value2.toString()})`;
throw new Error(message);
};
}
}
}
function configure2(options2) {
options2 = { ...options2 };
const fail = getStrictOption(options2);
if (fail) {
if (options2.bigint === void 0) {
options2.bigint = false;
}
if (!("circularValue" in options2)) {
options2.circularValue = Error;
}
}
const circularValue = getCircularValueOption(options2);
const bigint = getBooleanOption(options2, "bigint");
const deterministic = getDeterministicOption(options2);
const comparator = typeof deterministic === "function" ? deterministic : void 0;
const maximumDepth = getPositiveIntegerOption(options2, "maximumDepth");
const maximumBreadth = getPositiveIntegerOption(options2, "maximumBreadth");
function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
let value = parent[key];
if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
value = value.toJSON(key);
}
value = replacer.call(parent, key, value);
switch (typeof value) {
case "string":
return strEscape(value);
case "object": {
if (value === null) {
return "null";
}
if (stack.indexOf(value) !== -1) {
return circularValue;
}
let res = "";
let join2 = ",";
const originalIndentation = indentation;
if (Array.isArray(value)) {
if (value.length === 0) {
return "[]";
}
if (maximumDepth < stack.length + 1) {
return '"[Array]"';
}
stack.push(value);
if (spacer !== "") {
indentation += spacer;
res += `
${indentation}`;
join2 = `,
${indentation}`;
}
const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
let i = 0;
for (; i < maximumValuesToStringify - 1; i++) {
const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
res += tmp2 !== void 0 ? tmp2 : "null";
res += join2;
}
const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
res += tmp !== void 0 ? tmp : "null";
if (value.length - 1 > maximumBreadth) {
const removedKeys = value.length - maximumBreadth - 1;
res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
}
if (spacer !== "") {
res += `
${originalIndentation}`;
}
stack.pop();
return `[${res}]`;
}
let keys = Object.keys(value);
const keyLength = keys.length;
if (keyLength === 0) {
return "{}";
}
if (maximumDepth < stack.length + 1) {
return '"[Object]"';
}
let whitespace = "";
let separator = "";
if (spacer !== "") {
indentation += spacer;
join2 = `,
${indentation}`;
whitespace = " ";
}
const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
if (deterministic && !isTypedArrayWithEntries(value)) {
keys = sort(keys, comparator);
}
stack.push(value);
for (let i = 0; i < maximumPropertiesToStringify; i++) {
const key2 = keys[i];
const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
if (tmp !== void 0) {
res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
separator = join2;
}
}
if (keyLength > maximumBreadth) {
const removedKeys = keyLength - maximumBreadth;
res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
separator = join2;
}
if (spacer !== "" && separator.length > 1) {
res = `
${indentation}${res}
${originalIndentation}`;
}
stack.pop();
return `{${res}}`;
}
case "number":
return isFinite(value) ? String(value) : fail ? fail(value) : "null";
case "boolean":
return value === true ? "true" : "false";
case "undefined":
return void 0;
case "bigint":
if (bigint) {
return String(value);
}
// fallthrough
default:
return fail ? fail(value) : void 0;
}
}
function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
value = value.toJSON(key);
}
switch (typeof value) {
case "string":
return strEscape(value);
case "object": {
if (value === null) {
return "null";
}
if (stack.indexOf(value) !== -1) {
return circularValue;
}
const originalIndentation = indentation;
let res = "";
let join2 = ",";
if (Array.isArray(value)) {
if (value.length === 0) {
return "[]";
}
if (maximumDepth < stack.length + 1) {
return '"[Array]"';
}
stack.push(value);
if (spacer !== "") {
indentation += spacer;
res += `
${indentation}`;
join2 = `,
${indentation}`;
}
const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
let i = 0;
for (; i < maximumValuesToStringify - 1; i++) {
const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
res += tmp2 !== void 0 ? tmp2 : "null";
res += join2;
}
const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
res += tmp !== void 0 ? tmp : "null";
if (value.length - 1 > maximumBreadth) {
const removedKeys = value.length - maximumBreadth - 1;
res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
}
if (spacer !== "") {
res += `
${originalIndentation}`;
}
stack.pop();
return `[${res}]`;
}
stack.push(value);
let whitespace = "";
if (spacer !== "") {
indentation += spacer;
join2 = `,
${indentation}`;
whitespace = " ";
}
let separator = "";
for (const key2 of replacer) {
const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
if (tmp !== void 0) {
res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
separator = join2;
}
}
if (spacer !== "" && separator.length > 1) {
res = `
${indentation}${res}
${originalIndentation}`;