mcp-tally-api
Version:
Model Context Protocol server for Tally blockchain governance API - Access DAOs, proposals, and voting data across 15+ networks
1,638 lines (1,619 loc) • 2.49 MB
JavaScript
#!/usr/bin/env node
import { createRequire } from "node:module";
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __require = /* @__PURE__ */ createRequire(import.meta.url);
// node_modules/depd/index.js
var require_depd = __commonJS((exports, module) => {
/*!
* depd
* Copyright(c) 2014-2018 Douglas Christopher Wilson
* MIT Licensed
*/
var relative = __require("path").relative;
module.exports = depd;
var basePath = process.cwd();
function containsNamespace(str, namespace) {
var vals = str.split(/[ ,]+/);
var ns = String(namespace).toLowerCase();
for (var i = 0;i < vals.length; i++) {
var val = vals[i];
if (val && (val === "*" || val.toLowerCase() === ns)) {
return true;
}
}
return false;
}
function convertDataDescriptorToAccessor(obj, prop, message) {
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
var value = descriptor.value;
descriptor.get = function getter() {
return value;
};
if (descriptor.writable) {
descriptor.set = function setter(val) {
return value = val;
};
}
delete descriptor.value;
delete descriptor.writable;
Object.defineProperty(obj, prop, descriptor);
return descriptor;
}
function createArgumentsString(arity) {
var str = "";
for (var i = 0;i < arity; i++) {
str += ", arg" + i;
}
return str.substr(2);
}
function createStackString(stack) {
var str = this.name + ": " + this.namespace;
if (this.message) {
str += " deprecated " + this.message;
}
for (var i = 0;i < stack.length; i++) {
str += `
at ` + stack[i].toString();
}
return str;
}
function depd(namespace) {
if (!namespace) {
throw new TypeError("argument namespace is required");
}
var stack = getStack();
var site = callSiteLocation(stack[1]);
var file = site[0];
function deprecate(message) {
log.call(deprecate, message);
}
deprecate._file = file;
deprecate._ignored = isignored(namespace);
deprecate._namespace = namespace;
deprecate._traced = istraced(namespace);
deprecate._warned = Object.create(null);
deprecate.function = wrapfunction;
deprecate.property = wrapproperty;
return deprecate;
}
function eehaslisteners(emitter, type) {
var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
return count > 0;
}
function isignored(namespace) {
if (process.noDeprecation) {
return true;
}
var str = process.env.NO_DEPRECATION || "";
return containsNamespace(str, namespace);
}
function istraced(namespace) {
if (process.traceDeprecation) {
return true;
}
var str = process.env.TRACE_DEPRECATION || "";
return containsNamespace(str, namespace);
}
function log(message, site) {
var haslisteners = eehaslisteners(process, "deprecation");
if (!haslisteners && this._ignored) {
return;
}
var caller;
var callFile;
var callSite;
var depSite;
var i = 0;
var seen = false;
var stack = getStack();
var file = this._file;
if (site) {
depSite = site;
callSite = callSiteLocation(stack[1]);
callSite.name = depSite.name;
file = callSite[0];
} else {
i = 2;
depSite = callSiteLocation(stack[i]);
callSite = depSite;
}
for (;i < stack.length; i++) {
caller = callSiteLocation(stack[i]);
callFile = caller[0];
if (callFile === file) {
seen = true;
} else if (callFile === this._file) {
file = this._file;
} else if (seen) {
break;
}
}
var key = caller ? depSite.join(":") + "__" + caller.join(":") : undefined;
if (key !== undefined && key in this._warned) {
return;
}
this._warned[key] = true;
var msg = message;
if (!msg) {
msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite);
}
if (haslisteners) {
var err = DeprecationError(this._namespace, msg, stack.slice(i));
process.emit("deprecation", err);
return;
}
var format = process.stderr.isTTY ? formatColor : formatPlain;
var output = format.call(this, msg, caller, stack.slice(i));
process.stderr.write(output + `
`, "utf8");
}
function callSiteLocation(callSite) {
var file = callSite.getFileName() || "<anonymous>";
var line = callSite.getLineNumber();
var colm = callSite.getColumnNumber();
if (callSite.isEval()) {
file = callSite.getEvalOrigin() + ", " + file;
}
var site = [file, line, colm];
site.callSite = callSite;
site.name = callSite.getFunctionName();
return site;
}
function defaultMessage(site) {
var callSite = site.callSite;
var funcName = site.name;
if (!funcName) {
funcName = "<anonymous@" + formatLocation(site) + ">";
}
var context = callSite.getThis();
var typeName = context && callSite.getTypeName();
if (typeName === "Object") {
typeName = undefined;
}
if (typeName === "Function") {
typeName = context.name || typeName;
}
return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
}
function formatPlain(msg, caller, stack) {
var timestamp = new Date().toUTCString();
var formatted = timestamp + " " + this._namespace + " deprecated " + msg;
if (this._traced) {
for (var i = 0;i < stack.length; i++) {
formatted += `
at ` + stack[i].toString();
}
return formatted;
}
if (caller) {
formatted += " at " + formatLocation(caller);
}
return formatted;
}
function formatColor(msg, caller, stack) {
var formatted = "\x1B[36;1m" + this._namespace + "\x1B[22;39m" + " \x1B[33;1mdeprecated\x1B[22;39m" + " \x1B[0m" + msg + "\x1B[39m";
if (this._traced) {
for (var i = 0;i < stack.length; i++) {
formatted += `
\x1B[36mat ` + stack[i].toString() + "\x1B[39m";
}
return formatted;
}
if (caller) {
formatted += " \x1B[36m" + formatLocation(caller) + "\x1B[39m";
}
return formatted;
}
function formatLocation(callSite) {
return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
}
function getStack() {
var limit = Error.stackTraceLimit;
var obj = {};
var prep = Error.prepareStackTrace;
Error.prepareStackTrace = prepareObjectStackTrace;
Error.stackTraceLimit = Math.max(10, limit);
Error.captureStackTrace(obj);
var stack = obj.stack.slice(1);
Error.prepareStackTrace = prep;
Error.stackTraceLimit = limit;
return stack;
}
function prepareObjectStackTrace(obj, stack) {
return stack;
}
function wrapfunction(fn, message) {
if (typeof fn !== "function") {
throw new TypeError("argument fn must be a function");
}
var args = createArgumentsString(fn.length);
var stack = getStack();
var site = callSiteLocation(stack[1]);
site.name = fn.name;
var deprecatedfn = new Function("fn", "log", "deprecate", "message", "site", `"use strict"
` + "return function (" + args + ") {" + `log.call(deprecate, message, site)
` + `return fn.apply(this, arguments)
` + "}")(fn, log, this, message, site);
return deprecatedfn;
}
function wrapproperty(obj, prop, message) {
if (!obj || typeof obj !== "object" && typeof obj !== "function") {
throw new TypeError("argument obj must be object");
}
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
if (!descriptor) {
throw new TypeError("must call property on owner object");
}
if (!descriptor.configurable) {
throw new TypeError("property must be configurable");
}
var deprecate = this;
var stack = getStack();
var site = callSiteLocation(stack[1]);
site.name = prop;
if ("value" in descriptor) {
descriptor = convertDataDescriptorToAccessor(obj, prop, message);
}
var get = descriptor.get;
var set = descriptor.set;
if (typeof get === "function") {
descriptor.get = function getter() {
log.call(deprecate, message, site);
return get.apply(this, arguments);
};
}
if (typeof set === "function") {
descriptor.set = function setter() {
log.call(deprecate, message, site);
return set.apply(this, arguments);
};
}
Object.defineProperty(obj, prop, descriptor);
}
function DeprecationError(namespace, message, stack) {
var error = new Error;
var stackString;
Object.defineProperty(error, "constructor", {
value: DeprecationError
});
Object.defineProperty(error, "message", {
configurable: true,
enumerable: false,
value: message,
writable: true
});
Object.defineProperty(error, "name", {
enumerable: false,
configurable: true,
value: "DeprecationError",
writable: true
});
Object.defineProperty(error, "namespace", {
configurable: true,
enumerable: false,
value: namespace,
writable: true
});
Object.defineProperty(error, "stack", {
configurable: true,
enumerable: false,
get: function() {
if (stackString !== undefined) {
return stackString;
}
return stackString = createStackString.call(this, stack);
},
set: function setter(val) {
stackString = val;
}
});
return error;
}
});
// node_modules/bytes/index.js
var require_bytes = __commonJS((exports, module) => {
/*!
* bytes
* Copyright(c) 2012-2014 TJ Holowaychuk
* Copyright(c) 2015 Jed Watson
* MIT Licensed
*/
module.exports = bytes;
module.exports.format = format;
module.exports.parse = parse;
var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
var map = {
b: 1,
kb: 1 << 10,
mb: 1 << 20,
gb: 1 << 30,
tb: Math.pow(1024, 4),
pb: Math.pow(1024, 5)
};
var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
function bytes(value, options) {
if (typeof value === "string") {
return parse(value);
}
if (typeof value === "number") {
return format(value, options);
}
return null;
}
function format(value, options) {
if (!Number.isFinite(value)) {
return null;
}
var mag = Math.abs(value);
var thousandsSeparator = options && options.thousandsSeparator || "";
var unitSeparator = options && options.unitSeparator || "";
var decimalPlaces = options && options.decimalPlaces !== undefined ? options.decimalPlaces : 2;
var fixedDecimals = Boolean(options && options.fixedDecimals);
var unit = options && options.unit || "";
if (!unit || !map[unit.toLowerCase()]) {
if (mag >= map.pb) {
unit = "PB";
} else if (mag >= map.tb) {
unit = "TB";
} else if (mag >= map.gb) {
unit = "GB";
} else if (mag >= map.mb) {
unit = "MB";
} else if (mag >= map.kb) {
unit = "KB";
} else {
unit = "B";
}
}
var val = value / map[unit.toLowerCase()];
var str = val.toFixed(decimalPlaces);
if (!fixedDecimals) {
str = str.replace(formatDecimalsRegExp, "$1");
}
if (thousandsSeparator) {
str = str.split(".").map(function(s, i) {
return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s;
}).join(".");
}
return str + unitSeparator + unit;
}
function parse(val) {
if (typeof val === "number" && !isNaN(val)) {
return val;
}
if (typeof val !== "string") {
return null;
}
var results = parseRegExp.exec(val);
var floatValue;
var unit = "b";
if (!results) {
floatValue = parseInt(val, 10);
unit = "b";
} else {
floatValue = parseFloat(results[1]);
unit = results[4].toLowerCase();
}
if (isNaN(floatValue)) {
return null;
}
return Math.floor(map[unit] * floatValue);
}
});
// node_modules/content-type/index.js
var require_content_type = __commonJS((exports) => {
/*!
* content-type
* Copyright(c) 2015 Douglas Christopher Wilson
* MIT Licensed
*/
var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
var QUOTE_REGEXP = /([\\"])/g;
var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
exports.format = format;
exports.parse = parse;
function format(obj) {
if (!obj || typeof obj !== "object") {
throw new TypeError("argument obj is required");
}
var parameters = obj.parameters;
var type = obj.type;
if (!type || !TYPE_REGEXP.test(type)) {
throw new TypeError("invalid type");
}
var string = type;
if (parameters && typeof parameters === "object") {
var param;
var params = Object.keys(parameters).sort();
for (var i = 0;i < params.length; i++) {
param = params[i];
if (!TOKEN_REGEXP.test(param)) {
throw new TypeError("invalid parameter name");
}
string += "; " + param + "=" + qstring(parameters[param]);
}
}
return string;
}
function parse(string) {
if (!string) {
throw new TypeError("argument string is required");
}
var header = typeof string === "object" ? getcontenttype(string) : string;
if (typeof header !== "string") {
throw new TypeError("argument string is required to be a string");
}
var index = header.indexOf(";");
var type = index !== -1 ? header.slice(0, index).trim() : header.trim();
if (!TYPE_REGEXP.test(type)) {
throw new TypeError("invalid media type");
}
var obj = new ContentType(type.toLowerCase());
if (index !== -1) {
var key;
var match;
var value;
PARAM_REGEXP.lastIndex = index;
while (match = PARAM_REGEXP.exec(header)) {
if (match.index !== index) {
throw new TypeError("invalid parameter format");
}
index += match[0].length;
key = match[1].toLowerCase();
value = match[2];
if (value.charCodeAt(0) === 34) {
value = value.slice(1, -1);
if (value.indexOf("\\") !== -1) {
value = value.replace(QESC_REGEXP, "$1");
}
}
obj.parameters[key] = value;
}
if (index !== header.length) {
throw new TypeError("invalid parameter format");
}
}
return obj;
}
function getcontenttype(obj) {
var header;
if (typeof obj.getHeader === "function") {
header = obj.getHeader("content-type");
} else if (typeof obj.headers === "object") {
header = obj.headers && obj.headers["content-type"];
}
if (typeof header !== "string") {
throw new TypeError("content-type header is missing from object");
}
return header;
}
function qstring(val) {
var str = String(val);
if (TOKEN_REGEXP.test(str)) {
return str;
}
if (str.length > 0 && !TEXT_REGEXP.test(str)) {
throw new TypeError("invalid parameter value");
}
return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
}
function ContentType(type) {
this.parameters = Object.create(null);
this.type = type;
}
});
// node_modules/setprototypeof/index.js
var require_setprototypeof = __commonJS((exports, module) => {
module.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
function setProtoOf(obj, proto) {
obj.__proto__ = proto;
return obj;
}
function mixinProperties(obj, proto) {
for (var prop in proto) {
if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
obj[prop] = proto[prop];
}
}
return obj;
}
});
// node_modules/statuses/codes.json
var require_codes = __commonJS((exports, module) => {
module.exports = {
"100": "Continue",
"101": "Switching Protocols",
"102": "Processing",
"103": "Early Hints",
"200": "OK",
"201": "Created",
"202": "Accepted",
"203": "Non-Authoritative Information",
"204": "No Content",
"205": "Reset Content",
"206": "Partial Content",
"207": "Multi-Status",
"208": "Already Reported",
"226": "IM Used",
"300": "Multiple Choices",
"301": "Moved Permanently",
"302": "Found",
"303": "See Other",
"304": "Not Modified",
"305": "Use Proxy",
"307": "Temporary Redirect",
"308": "Permanent Redirect",
"400": "Bad Request",
"401": "Unauthorized",
"402": "Payment Required",
"403": "Forbidden",
"404": "Not Found",
"405": "Method Not Allowed",
"406": "Not Acceptable",
"407": "Proxy Authentication Required",
"408": "Request Timeout",
"409": "Conflict",
"410": "Gone",
"411": "Length Required",
"412": "Precondition Failed",
"413": "Payload Too Large",
"414": "URI Too Long",
"415": "Unsupported Media Type",
"416": "Range Not Satisfiable",
"417": "Expectation Failed",
"418": "I'm a Teapot",
"421": "Misdirected Request",
"422": "Unprocessable Entity",
"423": "Locked",
"424": "Failed Dependency",
"425": "Too Early",
"426": "Upgrade Required",
"428": "Precondition Required",
"429": "Too Many Requests",
"431": "Request Header Fields Too Large",
"451": "Unavailable For Legal Reasons",
"500": "Internal Server Error",
"501": "Not Implemented",
"502": "Bad Gateway",
"503": "Service Unavailable",
"504": "Gateway Timeout",
"505": "HTTP Version Not Supported",
"506": "Variant Also Negotiates",
"507": "Insufficient Storage",
"508": "Loop Detected",
"509": "Bandwidth Limit Exceeded",
"510": "Not Extended",
"511": "Network Authentication Required"
};
});
// node_modules/statuses/index.js
var require_statuses = __commonJS((exports, module) => {
/*!
* statuses
* Copyright(c) 2014 Jonathan Ong
* Copyright(c) 2016 Douglas Christopher Wilson
* MIT Licensed
*/
var codes = require_codes();
module.exports = status;
status.message = codes;
status.code = createMessageToStatusCodeMap(codes);
status.codes = createStatusCodeList(codes);
status.redirect = {
300: true,
301: true,
302: true,
303: true,
305: true,
307: true,
308: true
};
status.empty = {
204: true,
205: true,
304: true
};
status.retry = {
502: true,
503: true,
504: true
};
function createMessageToStatusCodeMap(codes2) {
var map = {};
Object.keys(codes2).forEach(function forEachCode(code) {
var message = codes2[code];
var status2 = Number(code);
map[message.toLowerCase()] = status2;
});
return map;
}
function createStatusCodeList(codes2) {
return Object.keys(codes2).map(function mapCode(code) {
return Number(code);
});
}
function getStatusCode(message) {
var msg = message.toLowerCase();
if (!Object.prototype.hasOwnProperty.call(status.code, msg)) {
throw new Error('invalid status message: "' + message + '"');
}
return status.code[msg];
}
function getStatusMessage(code) {
if (!Object.prototype.hasOwnProperty.call(status.message, code)) {
throw new Error("invalid status code: " + code);
}
return status.message[code];
}
function status(code) {
if (typeof code === "number") {
return getStatusMessage(code);
}
if (typeof code !== "string") {
throw new TypeError("code must be a number or string");
}
var n = parseInt(code, 10);
if (!isNaN(n)) {
return getStatusMessage(n);
}
return getStatusCode(code);
}
});
// node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS((exports, module) => {
if (typeof Object.create === "function") {
module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
};
} else {
module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor;
ctor.prototype.constructor = ctor;
}
};
}
});
// node_modules/inherits/inherits.js
var require_inherits = __commonJS((exports, module) => {
try {
util = __require("util");
if (typeof util.inherits !== "function")
throw "";
module.exports = util.inherits;
} catch (e) {
module.exports = require_inherits_browser();
}
var util;
});
// node_modules/toidentifier/index.js
var require_toidentifier = __commonJS((exports, module) => {
/*!
* toidentifier
* Copyright(c) 2016 Douglas Christopher Wilson
* MIT Licensed
*/
module.exports = toIdentifier;
function toIdentifier(str) {
return str.split(" ").map(function(token) {
return token.slice(0, 1).toUpperCase() + token.slice(1);
}).join("").replace(/[^ _0-9a-z]/gi, "");
}
});
// node_modules/http-errors/index.js
var require_http_errors = __commonJS((exports, module) => {
/*!
* http-errors
* Copyright(c) 2014 Jonathan Ong
* Copyright(c) 2016 Douglas Christopher Wilson
* MIT Licensed
*/
var deprecate = require_depd()("http-errors");
var setPrototypeOf = require_setprototypeof();
var statuses = require_statuses();
var inherits = require_inherits();
var toIdentifier = require_toidentifier();
module.exports = createError;
module.exports.HttpError = createHttpErrorConstructor();
module.exports.isHttpError = createIsHttpErrorFunction(module.exports.HttpError);
populateConstructorExports(module.exports, statuses.codes, module.exports.HttpError);
function codeClass(status) {
return Number(String(status).charAt(0) + "00");
}
function createError() {
var err;
var msg;
var status = 500;
var props = {};
for (var i = 0;i < arguments.length; i++) {
var arg = arguments[i];
var type = typeof arg;
if (type === "object" && arg instanceof Error) {
err = arg;
status = err.status || err.statusCode || status;
} else if (type === "number" && i === 0) {
status = arg;
} else if (type === "string") {
msg = arg;
} else if (type === "object") {
props = arg;
} else {
throw new TypeError("argument #" + (i + 1) + " unsupported type " + type);
}
}
if (typeof status === "number" && (status < 400 || status >= 600)) {
deprecate("non-error status code; use only 4xx or 5xx status codes");
}
if (typeof status !== "number" || !statuses.message[status] && (status < 400 || status >= 600)) {
status = 500;
}
var HttpError = createError[status] || createError[codeClass(status)];
if (!err) {
err = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status]);
Error.captureStackTrace(err, createError);
}
if (!HttpError || !(err instanceof HttpError) || err.status !== status) {
err.expose = status < 500;
err.status = err.statusCode = status;
}
for (var key in props) {
if (key !== "status" && key !== "statusCode") {
err[key] = props[key];
}
}
return err;
}
function createHttpErrorConstructor() {
function HttpError() {
throw new TypeError("cannot construct abstract class");
}
inherits(HttpError, Error);
return HttpError;
}
function createClientErrorConstructor(HttpError, name, code) {
var className = toClassName(name);
function ClientError(message) {
var msg = message != null ? message : statuses.message[code];
var err = new Error(msg);
Error.captureStackTrace(err, ClientError);
setPrototypeOf(err, ClientError.prototype);
Object.defineProperty(err, "message", {
enumerable: true,
configurable: true,
value: msg,
writable: true
});
Object.defineProperty(err, "name", {
enumerable: false,
configurable: true,
value: className,
writable: true
});
return err;
}
inherits(ClientError, HttpError);
nameFunc(ClientError, className);
ClientError.prototype.status = code;
ClientError.prototype.statusCode = code;
ClientError.prototype.expose = true;
return ClientError;
}
function createIsHttpErrorFunction(HttpError) {
return function isHttpError(val) {
if (!val || typeof val !== "object") {
return false;
}
if (val instanceof HttpError) {
return true;
}
return val instanceof Error && typeof val.expose === "boolean" && typeof val.statusCode === "number" && val.status === val.statusCode;
};
}
function createServerErrorConstructor(HttpError, name, code) {
var className = toClassName(name);
function ServerError(message) {
var msg = message != null ? message : statuses.message[code];
var err = new Error(msg);
Error.captureStackTrace(err, ServerError);
setPrototypeOf(err, ServerError.prototype);
Object.defineProperty(err, "message", {
enumerable: true,
configurable: true,
value: msg,
writable: true
});
Object.defineProperty(err, "name", {
enumerable: false,
configurable: true,
value: className,
writable: true
});
return err;
}
inherits(ServerError, HttpError);
nameFunc(ServerError, className);
ServerError.prototype.status = code;
ServerError.prototype.statusCode = code;
ServerError.prototype.expose = false;
return ServerError;
}
function nameFunc(func, name) {
var desc = Object.getOwnPropertyDescriptor(func, "name");
if (desc && desc.configurable) {
desc.value = name;
Object.defineProperty(func, "name", desc);
}
}
function populateConstructorExports(exports2, codes, HttpError) {
codes.forEach(function forEachCode(code) {
var CodeError;
var name = toIdentifier(statuses.message[code]);
switch (codeClass(code)) {
case 400:
CodeError = createClientErrorConstructor(HttpError, name, code);
break;
case 500:
CodeError = createServerErrorConstructor(HttpError, name, code);
break;
}
if (CodeError) {
exports2[code] = CodeError;
exports2[name] = CodeError;
}
});
}
function toClassName(name) {
return name.substr(-5) !== "Error" ? name + "Error" : name;
}
});
// node_modules/body-parser/node_modules/debug/node_modules/ms/index.js
var require_ms = __commonJS((exports, module) => {
var s = 1000;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var y = d * 365.25;
module.exports = function(val, options) {
options = options || {};
var type = typeof val;
if (type === "string" && val.length > 0) {
return parse(val);
} else if (type === "number" && isNaN(val) === false) {
return options.long ? fmtLong(val) : fmtShort(val);
}
throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
};
function parse(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
if (!match) {
return;
}
var n = parseFloat(match[1]);
var type = (match[2] || "ms").toLowerCase();
switch (type) {
case "years":
case "year":
case "yrs":
case "yr":
case "y":
return n * y;
case "days":
case "day":
case "d":
return n * d;
case "hours":
case "hour":
case "hrs":
case "hr":
case "h":
return n * h;
case "minutes":
case "minute":
case "mins":
case "min":
case "m":
return n * m;
case "seconds":
case "second":
case "secs":
case "sec":
case "s":
return n * s;
case "milliseconds":
case "millisecond":
case "msecs":
case "msec":
case "ms":
return n;
default:
return;
}
}
function fmtShort(ms) {
if (ms >= d) {
return Math.round(ms / d) + "d";
}
if (ms >= h) {
return Math.round(ms / h) + "h";
}
if (ms >= m) {
return Math.round(ms / m) + "m";
}
if (ms >= s) {
return Math.round(ms / s) + "s";
}
return ms + "ms";
}
function fmtLong(ms) {
return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
}
function plural(ms, n, name) {
if (ms < n) {
return;
}
if (ms < n * 1.5) {
return Math.floor(ms / n) + " " + name;
}
return Math.ceil(ms / n) + " " + name + "s";
}
});
// node_modules/body-parser/node_modules/debug/src/debug.js
var require_debug = __commonJS((exports, module) => {
exports = module.exports = createDebug.debug = createDebug["default"] = createDebug;
exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
exports.humanize = require_ms();
exports.names = [];
exports.skips = [];
exports.formatters = {};
var prevTime;
function selectColor(namespace) {
var hash = 0, i;
for (i in namespace) {
hash = (hash << 5) - hash + namespace.charCodeAt(i);
hash |= 0;
}
return exports.colors[Math.abs(hash) % exports.colors.length];
}
function createDebug(namespace) {
function debug() {
if (!debug.enabled)
return;
var self = debug;
var curr = +new Date;
var ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
var args = new Array(arguments.length);
for (var i = 0;i < args.length; i++) {
args[i] = arguments[i];
}
args[0] = exports.coerce(args[0]);
if (typeof args[0] !== "string") {
args.unshift("%O");
}
var index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
if (match === "%%")
return match;
index++;
var formatter = exports.formatters[format];
if (typeof formatter === "function") {
var val = args[index];
match = formatter.call(self, val);
args.splice(index, 1);
index--;
}
return match;
});
exports.formatArgs.call(self, args);
var logFn = debug.log || exports.log || console.log.bind(console);
logFn.apply(self, args);
}
debug.namespace = namespace;
debug.enabled = exports.enabled(namespace);
debug.useColors = exports.useColors();
debug.color = selectColor(namespace);
if (typeof exports.init === "function") {
exports.init(debug);
}
return debug;
}
function enable(namespaces) {
exports.save(namespaces);
exports.names = [];
exports.skips = [];
var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
var len = split.length;
for (var i = 0;i < len; i++) {
if (!split[i])
continue;
namespaces = split[i].replace(/\*/g, ".*?");
if (namespaces[0] === "-") {
exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
} else {
exports.names.push(new RegExp("^" + namespaces + "$"));
}
}
}
function disable() {
exports.enable("");
}
function enabled(name) {
var i, len;
for (i = 0, len = exports.skips.length;i < len; i++) {
if (exports.skips[i].test(name)) {
return false;
}
}
for (i = 0, len = exports.names.length;i < len; i++) {
if (exports.names[i].test(name)) {
return true;
}
}
return false;
}
function coerce(val) {
if (val instanceof Error)
return val.stack || val.message;
return val;
}
});
// node_modules/body-parser/node_modules/debug/src/browser.js
var require_browser = __commonJS((exports, module) => {
exports = module.exports = require_debug();
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = typeof chrome != "undefined" && typeof chrome.storage != "undefined" ? chrome.storage.local : localstorage();
exports.colors = [
"lightseagreen",
"forestgreen",
"goldenrod",
"dodgerblue",
"darkorchid",
"crimson"
];
function useColors() {
if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
return true;
}
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}
exports.formatters.j = function(v) {
try {
return JSON.stringify(v);
} catch (err) {
return "[UnexpectedJSONParseError]: " + err.message;
}
};
function formatArgs(args) {
var useColors2 = this.useColors;
args[0] = (useColors2 ? "%c" : "") + this.namespace + (useColors2 ? " %c" : " ") + args[0] + (useColors2 ? "%c " : " ") + "+" + exports.humanize(this.diff);
if (!useColors2)
return;
var c = "color: " + this.color;
args.splice(1, 0, c, "color: inherit");
var index = 0;
var lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, function(match) {
if (match === "%%")
return;
index++;
if (match === "%c") {
lastC = index;
}
});
args.splice(lastC, 0, c);
}
function log() {
return typeof console === "object" && console.log && Function.prototype.apply.call(console.log, console, arguments);
}
function save(namespaces) {
try {
if (namespaces == null) {
exports.storage.removeItem("debug");
} else {
exports.storage.debug = namespaces;
}
} catch (e) {
}
}
function load() {
var r;
try {
r = exports.storage.debug;
} catch (e) {
}
if (!r && typeof process !== "undefined" && "env" in process) {
r = process.env.DEBUG;
}
return r;
}
exports.enable(load());
function localstorage() {
try {
return window.localStorage;
} catch (e) {
}
}
});
// node_modules/body-parser/node_modules/debug/src/node.js
var require_node = __commonJS((exports, module) => {
var tty = __require("tty");
var util = __require("util");
exports = module.exports = require_debug();
exports.init = init;
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.colors = [6, 2, 3, 4, 5, 1];
exports.inspectOpts = Object.keys(process.env).filter(function(key) {
return /^debug_/i.test(key);
}).reduce(function(obj, key) {
var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
return k.toUpperCase();
});
var val = process.env[key];
if (/^(yes|on|true|enabled)$/i.test(val))
val = true;
else if (/^(no|off|false|disabled)$/i.test(val))
val = false;
else if (val === "null")
val = null;
else
val = Number(val);
obj[prop] = val;
return obj;
}, {});
var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
if (fd !== 1 && fd !== 2) {
util.deprecate(function() {
}, "except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)")();
}
var stream = fd === 1 ? process.stdout : fd === 2 ? process.stderr : createWritableStdioStream(fd);
function useColors() {
return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(fd);
}
exports.formatters.o = function(v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts).split(`
`).map(function(str) {
return str.trim();
}).join(" ");
};
exports.formatters.O = function(v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts);
};
function formatArgs(args) {
var name = this.namespace;
var useColors2 = this.useColors;
if (useColors2) {
var c = this.color;
var prefix = " \x1B[3" + c + ";1m" + name + " " + "\x1B[0m";
args[0] = prefix + args[0].split(`
`).join(`
` + prefix);
args.push("\x1B[3" + c + "m+" + exports.humanize(this.diff) + "\x1B[0m");
} else {
args[0] = new Date().toUTCString() + " " + name + " " + args[0];
}
}
function log() {
return stream.write(util.format.apply(util, arguments) + `
`);
}
function save(namespaces) {
if (namespaces == null) {
delete process.env.DEBUG;
} else {
process.env.DEBUG = namespaces;
}
}
function load() {
return process.env.DEBUG;
}
function createWritableStdioStream(fd2) {
var stream2;
var tty_wrap = process.binding("tty_wrap");
switch (tty_wrap.guessHandleType(fd2)) {
case "TTY":
stream2 = new tty.WriteStream(fd2);
stream2._type = "tty";
if (stream2._handle && stream2._handle.unref) {
stream2._handle.unref();
}
break;
case "FILE":
var fs = __require("fs");
stream2 = new fs.SyncWriteStream(fd2, { autoClose: false });
stream2._type = "fs";
break;
case "PIPE":
case "TCP":
var net = __require("net");
stream2 = new net.Socket({
fd: fd2,
readable: false,
writable: true
});
stream2.readable = false;
stream2.read = null;
stream2._type = "pipe";
if (stream2._handle && stream2._handle.unref) {
stream2._handle.unref();
}
break;
default:
throw new Error("Implement me. Unknown stream file type!");
}
stream2.fd = fd2;
stream2._isStdio = true;
return stream2;
}
function init(debug) {
debug.inspectOpts = {};
var keys = Object.keys(exports.inspectOpts);
for (var i = 0;i < keys.length; i++) {
debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
}
}
exports.enable(load());
});
// node_modules/body-parser/node_modules/debug/src/index.js
var require_src = __commonJS((exports, module) => {
if (typeof process !== "undefined" && process.type === "renderer") {
module.exports = require_browser();
} else {
module.exports = require_node();
}
});
// node_modules/destroy/index.js
var require_destroy = __commonJS((exports, module) => {
/*!
* destroy
* Copyright(c) 2014 Jonathan Ong
* Copyright(c) 2015-2022 Douglas Christopher Wilson
* MIT Licensed
*/
var EventEmitter = __require("events").EventEmitter;
var ReadStream = __require("fs").ReadStream;
var Stream = __require("stream");
var Zlib = __require("zlib");
module.exports = destroy;
function destroy(stream, suppress) {
if (isFsReadStream(stream)) {
destroyReadStream(stream);
} else if (isZlibStream(stream)) {
destroyZlibStream(stream);
} else if (hasDestroy(stream)) {
stream.destroy();
}
if (isEventEmitter(stream) && suppress) {
stream.removeAllListeners("error");
stream.addListener("error", noop);
}
return stream;
}
function destroyReadStream(stream) {
stream.destroy();
if (typeof stream.close === "function") {
stream.on("open", onOpenClose);
}
}
function closeZlibStream(stream) {
if (stream._hadError === true) {
var prop = stream._binding === null ? "_binding" : "_handle";
stream[prop] = {
close: function() {
this[prop] = null;
}
};
}
stream.close();
}
function destroyZlibStream(stream) {
if (typeof stream.destroy === "function") {
if (stream._binding) {
stream.destroy();
if (stream._processing) {
stream._needDrain = true;
stream.once("drain", onDrainClearBinding);
} else {
stream._binding.clear();
}
} else if (stream._destroy && stream._destroy !== Stream.Transform.prototype._destroy) {
stream.destroy();
} else if (stream._destroy && typeof stream.close === "function") {
stream.destroyed = true;
stream.close();
} else {
stream.destroy();
}
} else if (typeof stream.close === "function") {
closeZlibStream(stream);
}
}
function hasDestroy(stream) {
return stream instanceof Stream && typeof stream.destroy === "function";
}
function isEventEmitter(val) {
return val instanceof EventEmitter;
}
function isFsReadStream(stream) {
return stream instanceof ReadStream;
}
function isZlibStream(stream) {
return stream instanceof Zlib.Gzip || stream instanceof Zlib.Gunzip || stream instanceof Zlib.Deflate || stream instanceof Zlib.DeflateRaw || stream instanceof Zlib.Inflate || stream instanceof Zlib.InflateRaw || stream instanceof Zlib.Unzip;
}
function noop() {
}
function onDrainClearBinding() {
this._binding.clear();
}
function onOpenClose() {
if (typeof this.fd === "number") {
this.close();
}
}
});
// node_modules/safer-buffer/safer.js
var require_safer = __commonJS((exports, module) => {
var buffer = __require("buffer");
var Buffer2 = buffer.Buffer;
var safer = {};
var key;
for (key in buffer) {
if (!buffer.hasOwnProperty(key))
continue;
if (key === "SlowBuffer" || key === "Buffer")
continue;
safer[key] = buffer[key];
}
var Safer = safer.Buffer = {};
for (key in Buffer2) {
if (!Buffer2.hasOwnProperty(key))
continue;
if (key === "allocUnsafe" || key === "allocUnsafeSlow")
continue;
Safer[key] = Buffer2[key];
}
safer.Buffer.prototype = Buffer2.prototype;
if (!Safer.from || Safer.from === Uint8Array.from) {
Safer.from = function(value, encodingOrOffset, length) {
if (typeof value === "number") {
throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
}
if (value && typeof value.length === "undefined") {
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
}
return Buffer2(value, encodingOrOffset, length);
};
}
if (!Safer.alloc) {
Safer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") {
throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
}
if (size < 0 || size >= 2 * (1 << 30)) {
throw new RangeError('The value "' + size + '" is invalid for option "size"');
}
var buf = Buffer2(size);
if (!fill || fill.length === 0) {
buf.fill(0);
} else if (typeof encoding === "string") {
buf.fill(fill, encoding);
} else {
buf.fill(fill);
}
return buf;
};
}
if (!safer.kStringMaxLength) {
try {
safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
} catch (e) {
}
}
if (!safer.constants) {
safer.constants = {
MAX_LENGTH: safer.kMaxLength
};
if (safer.kStringMaxLength) {
safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
}
}
module.exports = safer;
});
// node_modules/body-parser/node_modules/iconv-lite/lib/bom-handling.js
var require_bom_handling = __commonJS((exports) => {
var BOMChar = "\uFEFF";
exports.PrependBOM = PrependBOMWrapper;
function PrependBOMWrapper(encoder, options) {
this.encoder = encoder;
this.addBOM = true;
}
PrependBOMWrapper.prototype.write = function(str) {
if (this.addBOM) {
str = BOMChar + str;
this.addBOM = false;
}
return this.encoder.write(str);
};
PrependBOMWrapper.prototype.end = function() {
return this.encoder.end();
};
exports.StripBOM = StripBOMWrapper;
function StripBOMWrapper(decoder, options) {
this.decoder = decoder;
this.pass = false;
this.options = options || {};
}
StripBOMWrapper.prototype.write = function(buf) {
var res = this.decoder.write(buf);
if (this.pass || !res)
return res;
if (res[0] === BOMChar) {
res = res.slice(1);
if (typeof this.options.stripBOM === "function")
this.options.stripBOM();
}
this.pass = true;
return res;
};
StripBOMWrapper.prototype.end = function() {
return this.decoder.end();
};
});
// node_modules/body-parser/node_modules/iconv-lite/encodings/internal.js
var require_internal = __commonJS((exports, module) => {
var Buffer2 = require_safer().Buffer;
module.exports = {
utf8: { type: "_internal", bomAware: true },
cesu8: { type: "_internal", bomAware: true },
unicode11utf8: "utf8",
ucs2: { type: "_internal", bomAware: true },
utf16le: "ucs2",
binary: { type: "_internal" },
base64: { type: "_internal" },
hex: { type: "_internal" },
_internal: InternalCodec
};
function InternalCodec(codecOptions, iconv) {
this.enc = codecOptions.encodingName;
this.bomAware = codecOptions.bomAware;
if (this.enc === "base64")
this.encoder = InternalEncoderBase64;
else if (this.enc === "cesu8") {
this.enc = "utf8";
this.encoder = InternalEncoderCesu8;
if (Buffer2.from("eda0bdedb2a9", "hex").toString() !== "\uD83D\uDCA9") {
this.decoder = InternalDecoderCesu8;
this.defaultCharUnicode = iconv.defaultCharUnicode;
}
}
}
InternalCodec.prototype.encoder = InternalEncoder;
InternalCodec.prototype.decoder = InternalDecoder;
var StringDecoder = __require("string_decoder").StringDecoder;
if (!StringDecoder.prototype.end)
StringDecoder.prototype.end = function() {
};
function InternalDecoder(options, codec) {
StringDecoder.call(this, codec.enc);
}
InternalDecoder.prototype = StringDecoder.prototype;
function InternalEncoder(options, codec) {
this.enc = codec.enc;
}
InternalEncoder.prototype.write = function(str) {
return Buffer2.from(str, this.enc);
};
InternalEncoder.prototype.end = function() {
};
function InternalEncoderBase64(options, codec) {
this.prevStr = "";
}
InternalEncoderBase64.prototype.write = function(str) {
str = this.prevStr + str;
var completeQuads = str.length - str.length % 4;
this.prevStr = str.slice(completeQuads);
str = str.slice(0, completeQuads);
return Buffer2.from(str, "base64");
};
InternalEncoderBase64.prototype.end = function() {
return Buffer2.from(this.prevStr, "base64");
};
function InternalEncoderCesu8(options, codec) {
}
InternalEncoderCesu8.prototype.write = function(str) {
var buf = Buffer2.alloc(str.length * 3), bufIdx = 0;
for (var i = 0;i < str.length; i++) {
var charCode = str.charCodeAt(i);
if (charCode < 128)
buf[bufIdx++] = charCode;
else if (charCode < 2048) {
buf[bufIdx++] = 192 + (charCode >>> 6);
buf[bufIdx++] = 128 + (charCode & 63);
} else {
buf[bufIdx++] = 224 + (charCode >>> 12);
buf[bufIdx++] = 128 + (charCode >>> 6 & 63);
buf[bufIdx++] = 128 + (charCode & 63);
}
}
return buf.slice(0, bufIdx);
};
InternalEncoderCesu8.prototype.end = function() {
};
function InternalDecoderCesu8(options, codec) {
this.acc = 0;
this.contBytes = 0;
this.accBytes = 0;
this.defaultCharUnicode = codec.defaultCharUnicode;
}
InternalDecoderCesu8.prototype.write = function(buf) {
var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = "";
for (var i = 0;i < buf.length; i++) {
var curByte = buf[i];
if ((curByte & 192) !== 128) {
if (contBytes > 0) {
res += this.defaultCharUnicode;
contBytes = 0;
}
if (cu