@unidev-hub/api-framework
Version:
A comprehensive framework for building API services with Express
1,618 lines (1,601 loc) • 1.48 MB
JavaScript
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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
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 __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except2, desc2) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except2)
__defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.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
));
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
// node_modules/depd/index.js
var require_depd = __commonJS({
"node_modules/depd/index.js"(exports, module) {
"use strict";
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 += "\n 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 = /* @__PURE__ */ 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(":") : void 0;
if (key !== void 0 && 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 + "\n", "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 = void 0;
}
if (typeName === "Function") {
typeName = context.name || typeName;
}
return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
}
function formatPlain(msg, caller, stack) {
var timestamp = (/* @__PURE__ */ new Date()).toUTCString();
var formatted = timestamp + " " + this._namespace + " deprecated " + msg;
if (this._traced) {
for (var i = 0; i < stack.length; i++) {
formatted += "\n 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 += "\n \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"\nreturn function (' + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}"
)(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 !== void 0) {
return stackString;
}
return stackString = createStackString.call(this, stack);
},
set: function setter(val) {
stackString = val;
}
});
return error;
}
}
});
// node_modules/setprototypeof/index.js
var require_setprototypeof = __commonJS({
"node_modules/setprototypeof/index.js"(exports, module) {
"use strict";
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({
"node_modules/statuses/codes.json"(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({
"node_modules/statuses/index.js"(exports, module) {
"use strict";
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({
"node_modules/inherits/inherits_browser.js"(exports, module) {
"use strict";
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({
"node_modules/inherits/inherits.js"(exports, module) {
"use strict";
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({
"node_modules/toidentifier/index.js"(exports, module) {
"use strict";
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({
"node_modules/http-errors/index.js"(exports, module) {
"use strict";
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 HttpError2 = createError[status] || createError[codeClass(status)];
if (!err) {
err = HttpError2 ? new HttpError2(msg) : new Error(msg || statuses.message[status]);
Error.captureStackTrace(err, createError);
}
if (!HttpError2 || !(err instanceof HttpError2) || 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 HttpError2() {
throw new TypeError("cannot construct abstract class");
}
inherits(HttpError2, Error);
return HttpError2;
}
function createClientErrorConstructor(HttpError2, 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, HttpError2);
nameFunc(ClientError, className);
ClientError.prototype.status = code;
ClientError.prototype.statusCode = code;
ClientError.prototype.expose = true;
return ClientError;
}
function createIsHttpErrorFunction(HttpError2) {
return function isHttpError(val) {
if (!val || typeof val !== "object") {
return false;
}
if (val instanceof HttpError2) {
return true;
}
return val instanceof Error && typeof val.expose === "boolean" && typeof val.statusCode === "number" && val.status === val.statusCode;
};
}
function createServerErrorConstructor(HttpError2, 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, HttpError2);
nameFunc(ServerError, className);
ServerError.prototype.status = code;
ServerError.prototype.statusCode = code;
ServerError.prototype.expose = false;
return ServerError;
}
function nameFunc(func, name) {
var desc2 = Object.getOwnPropertyDescriptor(func, "name");
if (desc2 && desc2.configurable) {
desc2.value = name;
Object.defineProperty(func, "name", desc2);
}
}
function populateConstructorExports(exports2, codes, HttpError2) {
codes.forEach(function forEachCode(code) {
var CodeError;
var name = toIdentifier(statuses.message[code]);
switch (codeClass(code)) {
case 400:
CodeError = createClientErrorConstructor(HttpError2, name, code);
break;
case 500:
CodeError = createServerErrorConstructor(HttpError2, name, code);
break;
}
if (CodeError) {
exports2[code] = CodeError;
exports2[name] = CodeError;
}
});
}
function toClassName(name) {
return name.substr(-5) !== "Error" ? name + "Error" : name;
}
}
});
// node_modules/ms/index.js
var require_ms = __commonJS({
"node_modules/ms/index.js"(exports, module) {
"use strict";
var s = 1e3;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var w = d * 7;
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" && isFinite(val)) {
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|weeks?|w|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 "weeks":
case "week":
case "w":
return n * w;
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 void 0;
}
}
function fmtShort(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return Math.round(ms / d) + "d";
}
if (msAbs >= h) {
return Math.round(ms / h) + "h";
}
if (msAbs >= m) {
return Math.round(ms / m) + "m";
}
if (msAbs >= s) {
return Math.round(ms / s) + "s";
}
return ms + "ms";
}
function fmtLong(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return plural(ms, msAbs, d, "day");
}
if (msAbs >= h) {
return plural(ms, msAbs, h, "hour");
}
if (msAbs >= m) {
return plural(ms, msAbs, m, "minute");
}
if (msAbs >= s) {
return plural(ms, msAbs, s, "second");
}
return ms + " ms";
}
function plural(ms, msAbs, n, name) {
var isPlural = msAbs >= n * 1.5;
return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
}
}
});
// node_modules/debug/src/common.js
var require_common = __commonJS({
"node_modules/debug/src/common.js"(exports, module) {
"use strict";
function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = require_ms();
createDebug.destroy = destroy;
Object.keys(env).forEach((key) => {
createDebug[key] = env[key];
});
createDebug.names = [];
createDebug.skips = [];
createDebug.formatters = {};
function selectColor(namespace) {
let hash = 0;
for (let i = 0; i < namespace.length; i++) {
hash = (hash << 5) - hash + namespace.charCodeAt(i);
hash |= 0;
}
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
}
createDebug.selectColor = selectColor;
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;
function debug(...args) {
if (!debug.enabled) {
return;
}
const self = debug;
const curr = Number(/* @__PURE__ */ new Date());
const ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
args[0] = createDebug.coerce(args[0]);
if (typeof args[0] !== "string") {
args.unshift("%O");
}
let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
if (match === "%%") {
return "%";
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === "function") {
const val = args[index];
match = formatter.call(self, val);
args.splice(index, 1);
index--;
}
return match;
});
createDebug.formatArgs.call(self, args);
const logFn = self.log || createDebug.log;
logFn.apply(self, args);
}
debug.namespace = namespace;
debug.useColors = createDebug.useColors();
debug.color = createDebug.selectColor(namespace);
debug.extend = extend;
debug.destroy = createDebug.destroy;
Object.defineProperty(debug, "enabled", {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}
return enabledCache;
},
set: (v3) => {
enableOverride = v3;
}
});
if (typeof createDebug.init === "function") {
createDebug.init(debug);
}
return debug;
}
function extend(namespace, delimiter) {
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;
createDebug.names = [];
createDebug.skips = [];
const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
for (const ns of split) {
if (ns[0] === "-") {
createDebug.skips.push(ns.slice(1));
} else {
createDebug.names.push(ns);
}
}
}
function matchesTemplate(search, template) {
let searchIndex = 0;
let templateIndex = 0;
let starIndex = -1;
let matchIndex = 0;
while (searchIndex < search.length) {
if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
if (template[templateIndex] === "*") {
starIndex = templateIndex;
matchIndex = searchIndex;
templateIndex++;
} else {
searchIndex++;
templateIndex++;
}
} else if (starIndex !== -1) {
templateIndex = starIndex + 1;
matchIndex++;
searchIndex = matchIndex;
} else {
return false;
}
}
while (templateIndex < template.length && template[templateIndex] === "*") {
templateIndex++;
}
return templateIndex === template.length;
}
function disable() {
const namespaces = [
...createDebug.names,
...createDebug.skips.map((namespace) => "-" + namespace)
].join(",");
createDebug.enable("");
return namespaces;
}
function enabled(name) {
for (const skip of createDebug.skips) {
if (matchesTemplate(name, skip)) {
return false;
}
}
for (const ns of createDebug.names) {
if (matchesTemplate(name, ns)) {
return true;
}
}
return false;
}
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}
function destroy() {
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
createDebug.enable(createDebug.load());
return createDebug;
}
module.exports = setup;
}
});
// node_modules/debug/src/browser.js
var require_browser = __commonJS({
"node_modules/debug/src/browser.js"(exports, module) {
"use strict";
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = localstorage();
exports.destroy = /* @__PURE__ */ (() => {
let warned = false;
return () => {
if (!warned) {
warned = true;
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
};
})();
exports.colors = [
"#0000CC",
"#0000FF",
"#0033CC",
"#0033FF",
"#0066CC",
"#0066FF",
"#0099CC",
"#0099FF",
"#00CC00",
"#00CC33",
"#00CC66",
"#00CC99",
"#00CCCC",
"#00CCFF",
"#3300CC",
"#3300FF",
"#3333CC",
"#3333FF",
"#3366CC",
"#3366FF",
"#3399CC",
"#3399FF",
"#33CC00",
"#33CC33",
"#33CC66",
"#33CC99",
"#33CCCC",
"#33CCFF",
"#6600CC",
"#6600FF",
"#6633CC",
"#6633FF",
"#66CC00",
"#66CC33",
"#9900CC",
"#9900FF",
"#9933CC",
"#9933FF",
"#99CC00",
"#99CC33",
"#CC0000",
"#CC0033",
"#CC0066",
"#CC0099",
"#CC00CC",
"#CC00FF",
"#CC3300",
"#CC3333",
"#CC3366",
"#CC3399",
"#CC33CC",
"#CC33FF",
"#CC6600",
"#CC6633",
"#CC9900",
"#CC9933",
"#CCCC00",
"#CCCC33",
"#FF0000",
"#FF0033",
"#FF0066",
"#FF0099",
"#FF00CC",
"#FF00FF",
"#FF3300",
"#FF3333",
"#FF3366",
"#FF3399",
"#FF33CC",
"#FF33FF",
"#FF6600",
"#FF6633",
"#FF9900",
"#FF9933",
"#FFCC00",
"#FFCC33"
];
function useColors() {
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
return true;
}
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
return false;
}
let m;
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}
function formatArgs(args) {
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
if (!this.useColors) {
return;
}
const c = "color: " + this.color;
args.splice(1, 0, c, "color: inherit");
let index = 0;
let lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, (match) => {
if (match === "%%") {
return;
}
index++;
if (match === "%c") {
lastC = index;
}
});
args.splice(lastC, 0, c);
}
exports.log = console.debug || console.log || (() => {
});
function save(namespaces) {
try {
if (namespaces) {
exports.storage.setItem("debug", namespaces);
} else {
exports.storage.removeItem("debug");
}
} catch (error) {
}
}
function load() {
let r;
try {
r = exports.storage.getItem("debug");
} catch (error) {
}
if (!r && typeof process !== "undefined" && "env" in process) {
r = process.env.DEBUG;
}
return r;
}
function localstorage() {
try {
return localStorage;
} catch (error) {
}
}
module.exports = require_common()(exports);
var { formatters } = module.exports;
formatters.j = function(v3) {
try {
return JSON.stringify(v3);
} catch (error) {
return "[UnexpectedJSONParseError]: " + error.message;
}
};
}
});
// node_modules/has-flag/index.js
var require_has_flag = __commonJS({
"node_modules/has-flag/index.js"(exports, module) {
"use strict";
module.exports = (flag, argv = process.argv) => {
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
const position = argv.indexOf(prefix + flag);
const terminatorPosition = argv.indexOf("--");
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
};
}
});
// node_modules/supports-color/index.js
var require_supports_color = __commonJS({
"node_modules/supports-color/index.js"(exports, module) {
"use strict";
var os = __require("os");
var tty = __require("tty");
var hasFlag = require_has_flag();
var { env } = process;
var forceColor;
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
forceColor = 0;
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
forceColor = 1;
}
if ("FORCE_COLOR" in env) {
if (env.FORCE_COLOR === "true") {
forceColor = 1;
} else if (env.FORCE_COLOR === "false") {
forceColor = 0;
} else {
forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
}
}
function translateLevel(level) {
if (level === 0) {
return false;
}
return {
level,
hasBasic: true,
has256: level >= 2,
has16m: level >= 3
};
}
function supportsColor(haveStream, streamIsTTY) {
if (forceColor === 0) {
return 0;
}
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
return 3;
}
if (hasFlag("color=256")) {
return 2;
}
if (haveStream && !streamIsTTY && forceColor === void 0) {
return 0;
}
const min = forceColor || 0;
if (env.TERM === "dumb") {
return min;
}
if (process.platform === "win32") {
const osRelease = os.release().split(".");
if (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", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => 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 (env.COLORTERM === "truecolor") {
return 3;
}
if ("TERM_PROGRAM" in env) {
const version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
switch (env.TERM_PROGRAM) {
case "iTerm.app":
return version2 >= 3 ? 3 : 2;
case "Apple_Terminal":
return 2;
}
}
if (/-256(color)?$/i.test(env.TERM)) {
return 2;
}
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
return 1;
}
if ("COLORTERM" in env) {
return 1;
}
return min;
}
function getSupportLevel(stream) {
const level = supportsColor(stream, stream && stream.isTTY);
return translateLevel(level);
}
module.exports = {
supportsColor: getSupportLevel,
stdout: translateLevel(supportsColor(true, tty.isatty(1))),
stderr: translateLevel(supportsColor(true, tty.isatty(2)))
};
}
});
// node_modules/debug/src/node.js
var require_node = __commonJS({
"node_modules/debug/src/node.js"(exports, module) {
"use strict";
var tty = __require("tty");
var util = __require("util");
exports.init = init;
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.destroy = util.deprecate(
() => {
},
"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
);
exports.colors = [6, 2, 3, 4, 5, 1];
try {
const supportsColor = require_supports_color();
if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
exports.colors = [
20,
21,
26,
27,
32,
33,
38,
39,
40,
41,
42,
43,
44,
45,
56,
57,
62,
63,
68,
69,
74,
75,
76,
77,
78,
79,
80,
81,
92,
93,
98,
99,
112,
113,
128,
129,
134,
135,
148,
149,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
178,
179,
184,
185,
196,
197,
198,
199,
200,
201,
202,
203,
204,
205,
206,
207,
208,
209,
214,
215,
220,
221
];
}
} catch (error) {
}
exports.inspectOpts = Object.keys(process.env).filter((key) => {
return /^debug_/i.test(key);
}).reduce((obj, key) => {
const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
return k.toUpperCase();
});
let 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;
}, {});
function useColors() {
return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
}
function formatArgs(args) {
const { namespace: name, useColors: useColors2 } = this;
if (useColors2) {
const c = this.color;
const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
const prefix = ` ${colorCode};1m${name} \x1B[0m`;
args[0] = prefix + args[0].split("\n").join("\n" + prefix);
args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
} else {
args[0] = getDate() + name + " " + args[0];
}
}
function getDate() {
if (exports.inspectOpts.hideDate) {
return "";
}
return (/* @__PURE__ */ new Date()).toISOString() + " ";
}
function log(...args) {
return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
}
function save(namespaces) {
if (namespaces) {
process.env.DEBUG = namespaces;
} else {
delete process.env.DEBUG;
}
}
function load() {
return process.env.DEBUG;
}
function init(debug) {
debug.inspectOpts = {};
const keys = Object.keys(exports.inspectOpts);
for (let i = 0; i < keys.length; i++) {
debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
}
}
module.exports = require_common()(exports);
var { formatters } = module.exports;
formatters.o = function(v3) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v3, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
};
formatters.O = function(v3) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v3, this.inspectOpts);
};
}
});
// node_modules/debug/src/index.js
var require_src = __commonJS({
"node_modules/debug/src/index.js"(exports, module) {
"use strict";
if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
module.exports = require_browser();
} else {
module.exports = require_node();
}
}
});
// node_modules/ee-first/index.js
var require_ee_first = __commonJS({
"node_modules/ee-first/index.js"(exports, module) {
"use strict";
module.exports = first;
function first(stuff, done) {
if (!Array.isArray(stuff))
throw new TypeError("arg must be an array of [ee, events...] arrays");
var cleanups = [];
for (var i = 0; i < stuff.length; i++) {
var arr = stuff[i];
if (!Array.isArray(arr) || arr.length < 2)
throw new TypeError("each array member must be [ee, events...]");
var ee = arr[0];
for (var j = 1; j < arr.length; j++) {
var event = arr[j];
var fn = listener(event, callback);
ee.on(event, fn);
cleanups.push({
ee,
event,
fn
});
}
}
function callback() {
cleanup();
done.apply(null, arguments);
}
function cleanup() {
var x;
for (var i2 = 0; i2 < cleanups.length; i2++) {
x = cleanups[i2];
x.ee.removeListener(x.event, x.fn);
}
}
function thunk(fn2) {
done = fn2;
}
thunk.cancel = cleanup;
return thunk;
}
function listener(event, done) {
return function onevent(arg1) {
var args = new Array(arguments.length);
var ee = this;
var err = event === "error" ? arg1 : null;
for (var i = 0; i < args.length; i++) {
args[i] = arguments[i];
}
done(err, ee, event, args);
};
}
}
});
// node_modules/on-finished/index.js
var require_on_finished = __commonJS({
"node_modules/on-finished/index.js"(exports, module) {
"use strict";
module.exports = onFinished;
module.exports.isFinished = isFinished;
var asyncHooks = tryRequireAsyncHooks();
var first = require_ee_first();
var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
process.nextTick(fn.bind.apply(fn, arguments));
};
function onFinished(msg, listener) {
if (isFinished(msg) !== false) {
defer(listener, null, msg);
return msg;
}
attachListener(msg, wrap(listener));
return msg;
}
function isFinished(msg) {
var socket = msg.socket;
if (typeof msg.finished === "boolean") {
return Boolean(msg.finished || socket && !socket.writable);
}
if (typeof msg.complete === "boolean") {
return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
}
return void 0;
}
function attachFinishedListener(msg, callback) {
var eeMsg;
var eeSocket;
var finished = false;
function onFinish(error) {
eeMsg.cancel();
eeSocket.cancel();
finished = true;
callback(error);
}
eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish);
function onSocket(socket) {
msg.removeListener("socket", onSocket);
if (finished) return;
if (eeMsg !== eeSocket) return;
eeSocket = first([[socket, "error", "close"]], onFinish);
}
if (msg.socket) {
onSocket(msg.socket);
return;
}
msg.on("socket", onSocket);
if (msg.socket === void 0) {
patchAssignSocket(msg, onSocket);
}
}
function attachListener(msg, listener) {
var attached = msg.__onFinished;
if (!attached || !attached.queue) {
attached = msg.__onFinished = createListener(msg);
attachFinishedListener(msg, attached);
}
attached.queue.push(listener);
}
function createListener(msg) {
function listener(err) {
if (msg.__onFinished === lis