apitally
Version:
Simple API monitoring & analytics for REST APIs built with Express, Fastify, NestJS, AdonisJS, Hono, H3, Elysia, Hapi, and Koa.
1,517 lines (1,494 loc) • 163 kB
JavaScript
"use strict";
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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/pino-std-serializers/lib/err-helpers.js
var require_err_helpers = __commonJS({
"node_modules/pino-std-serializers/lib/err-helpers.js"(exports2, module2) {
"use strict";
var isErrorLike = /* @__PURE__ */ __name((err) => {
return err && typeof err.message === "string";
}, "isErrorLike");
var getErrorCause = /* @__PURE__ */ __name((err) => {
if (!err) return;
const cause = err.cause;
if (typeof cause === "function") {
const causeResult = err.cause();
return isErrorLike(causeResult) ? causeResult : void 0;
} else {
return isErrorLike(cause) ? cause : void 0;
}
}, "getErrorCause");
var _stackWithCauses = /* @__PURE__ */ __name((err, seen) => {
if (!isErrorLike(err)) return "";
const stack = err.stack || "";
if (seen.has(err)) {
return stack + "\ncauses have become circular...";
}
const cause = getErrorCause(err);
if (cause) {
seen.add(err);
return stack + "\ncaused by: " + _stackWithCauses(cause, seen);
} else {
return stack;
}
}, "_stackWithCauses");
var stackWithCauses = /* @__PURE__ */ __name((err) => _stackWithCauses(err, /* @__PURE__ */ new Set()), "stackWithCauses");
var _messageWithCauses = /* @__PURE__ */ __name((err, seen, skip) => {
if (!isErrorLike(err)) return "";
const message = skip ? "" : err.message || "";
if (seen.has(err)) {
return message + ": ...";
}
const cause = getErrorCause(err);
if (cause) {
seen.add(err);
const skipIfVErrorStyleCause = typeof err.cause === "function";
return message + (skipIfVErrorStyleCause ? "" : ": ") + _messageWithCauses(cause, seen, skipIfVErrorStyleCause);
} else {
return message;
}
}, "_messageWithCauses");
var messageWithCauses = /* @__PURE__ */ __name((err) => _messageWithCauses(err, /* @__PURE__ */ new Set()), "messageWithCauses");
module2.exports = {
isErrorLike,
getErrorCause,
stackWithCauses,
messageWithCauses
};
}
});
// node_modules/pino-std-serializers/lib/err-proto.js
var require_err_proto = __commonJS({
"node_modules/pino-std-serializers/lib/err-proto.js"(exports2, module2) {
"use strict";
var seen = Symbol("circular-ref-tag");
var rawSymbol = Symbol("pino-raw-err-ref");
var pinoErrProto = Object.create({}, {
type: {
enumerable: true,
writable: true,
value: void 0
},
message: {
enumerable: true,
writable: true,
value: void 0
},
stack: {
enumerable: true,
writable: true,
value: void 0
},
aggregateErrors: {
enumerable: true,
writable: true,
value: void 0
},
raw: {
enumerable: false,
get: /* @__PURE__ */ __name(function() {
return this[rawSymbol];
}, "get"),
set: /* @__PURE__ */ __name(function(val) {
this[rawSymbol] = val;
}, "set")
}
});
Object.defineProperty(pinoErrProto, rawSymbol, {
writable: true,
value: {}
});
module2.exports = {
pinoErrProto,
pinoErrorSymbols: {
seen,
rawSymbol
}
};
}
});
// node_modules/pino-std-serializers/lib/err.js
var require_err = __commonJS({
"node_modules/pino-std-serializers/lib/err.js"(exports2, module2) {
"use strict";
module2.exports = errSerializer;
var { messageWithCauses, stackWithCauses, isErrorLike } = require_err_helpers();
var { pinoErrProto, pinoErrorSymbols } = require_err_proto();
var { seen } = pinoErrorSymbols;
var { toString } = Object.prototype;
function errSerializer(err) {
if (!isErrorLike(err)) {
return err;
}
err[seen] = void 0;
const _err = Object.create(pinoErrProto);
_err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name;
_err.message = messageWithCauses(err);
_err.stack = stackWithCauses(err);
if (Array.isArray(err.errors)) {
_err.aggregateErrors = err.errors.map((err2) => errSerializer(err2));
}
for (const key in err) {
if (_err[key] === void 0) {
const val = err[key];
if (isErrorLike(val)) {
if (key !== "cause" && !Object.prototype.hasOwnProperty.call(val, seen)) {
_err[key] = errSerializer(val);
}
} else {
_err[key] = val;
}
}
}
delete err[seen];
_err.raw = err;
return _err;
}
__name(errSerializer, "errSerializer");
}
});
// node_modules/pino-std-serializers/lib/err-with-cause.js
var require_err_with_cause = __commonJS({
"node_modules/pino-std-serializers/lib/err-with-cause.js"(exports2, module2) {
"use strict";
module2.exports = errWithCauseSerializer;
var { isErrorLike } = require_err_helpers();
var { pinoErrProto, pinoErrorSymbols } = require_err_proto();
var { seen } = pinoErrorSymbols;
var { toString } = Object.prototype;
function errWithCauseSerializer(err) {
if (!isErrorLike(err)) {
return err;
}
err[seen] = void 0;
const _err = Object.create(pinoErrProto);
_err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name;
_err.message = err.message;
_err.stack = err.stack;
if (Array.isArray(err.errors)) {
_err.aggregateErrors = err.errors.map((err2) => errWithCauseSerializer(err2));
}
if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
_err.cause = errWithCauseSerializer(err.cause);
}
for (const key in err) {
if (_err[key] === void 0) {
const val = err[key];
if (isErrorLike(val)) {
if (!Object.prototype.hasOwnProperty.call(val, seen)) {
_err[key] = errWithCauseSerializer(val);
}
} else {
_err[key] = val;
}
}
}
delete err[seen];
_err.raw = err;
return _err;
}
__name(errWithCauseSerializer, "errWithCauseSerializer");
}
});
// node_modules/pino-std-serializers/lib/req.js
var require_req = __commonJS({
"node_modules/pino-std-serializers/lib/req.js"(exports2, module2) {
"use strict";
module2.exports = {
mapHttpRequest,
reqSerializer
};
var rawSymbol = Symbol("pino-raw-req-ref");
var pinoReqProto = Object.create({}, {
id: {
enumerable: true,
writable: true,
value: ""
},
method: {
enumerable: true,
writable: true,
value: ""
},
url: {
enumerable: true,
writable: true,
value: ""
},
query: {
enumerable: true,
writable: true,
value: ""
},
params: {
enumerable: true,
writable: true,
value: ""
},
headers: {
enumerable: true,
writable: true,
value: {}
},
remoteAddress: {
enumerable: true,
writable: true,
value: ""
},
remotePort: {
enumerable: true,
writable: true,
value: ""
},
raw: {
enumerable: false,
get: /* @__PURE__ */ __name(function() {
return this[rawSymbol];
}, "get"),
set: /* @__PURE__ */ __name(function(val) {
this[rawSymbol] = val;
}, "set")
}
});
Object.defineProperty(pinoReqProto, rawSymbol, {
writable: true,
value: {}
});
function reqSerializer(req) {
const connection = req.info || req.socket;
const _req = Object.create(pinoReqProto);
_req.id = typeof req.id === "function" ? req.id() : req.id || (req.info ? req.info.id : void 0);
_req.method = req.method;
if (req.originalUrl) {
_req.url = req.originalUrl;
} else {
const path = req.path;
_req.url = typeof path === "string" ? path : req.url ? req.url.path || req.url : void 0;
}
if (req.query) {
_req.query = req.query;
}
if (req.params) {
_req.params = req.params;
}
_req.headers = req.headers;
_req.remoteAddress = connection && connection.remoteAddress;
_req.remotePort = connection && connection.remotePort;
_req.raw = req.raw || req;
return _req;
}
__name(reqSerializer, "reqSerializer");
function mapHttpRequest(req) {
return {
req: reqSerializer(req)
};
}
__name(mapHttpRequest, "mapHttpRequest");
}
});
// node_modules/pino-std-serializers/lib/res.js
var require_res = __commonJS({
"node_modules/pino-std-serializers/lib/res.js"(exports2, module2) {
"use strict";
module2.exports = {
mapHttpResponse,
resSerializer
};
var rawSymbol = Symbol("pino-raw-res-ref");
var pinoResProto = Object.create({}, {
statusCode: {
enumerable: true,
writable: true,
value: 0
},
headers: {
enumerable: true,
writable: true,
value: ""
},
raw: {
enumerable: false,
get: /* @__PURE__ */ __name(function() {
return this[rawSymbol];
}, "get"),
set: /* @__PURE__ */ __name(function(val) {
this[rawSymbol] = val;
}, "set")
}
});
Object.defineProperty(pinoResProto, rawSymbol, {
writable: true,
value: {}
});
function resSerializer(res) {
const _res = Object.create(pinoResProto);
_res.statusCode = res.headersSent ? res.statusCode : null;
_res.headers = res.getHeaders ? res.getHeaders() : res._headers;
_res.raw = res;
return _res;
}
__name(resSerializer, "resSerializer");
function mapHttpResponse(res) {
return {
res: resSerializer(res)
};
}
__name(mapHttpResponse, "mapHttpResponse");
}
});
// node_modules/pino-std-serializers/index.js
var require_pino_std_serializers = __commonJS({
"node_modules/pino-std-serializers/index.js"(exports2, module2) {
"use strict";
var errSerializer = require_err();
var errWithCauseSerializer = require_err_with_cause();
var reqSerializers = require_req();
var resSerializers = require_res();
module2.exports = {
err: errSerializer,
errWithCause: errWithCauseSerializer,
mapHttpRequest: reqSerializers.mapHttpRequest,
mapHttpResponse: resSerializers.mapHttpResponse,
req: reqSerializers.reqSerializer,
res: resSerializers.resSerializer,
wrapErrorSerializer: /* @__PURE__ */ __name(function wrapErrorSerializer(customSerializer) {
if (customSerializer === errSerializer) return customSerializer;
return /* @__PURE__ */ __name(function wrapErrSerializer(err) {
return customSerializer(errSerializer(err));
}, "wrapErrSerializer");
}, "wrapErrorSerializer"),
wrapRequestSerializer: /* @__PURE__ */ __name(function wrapRequestSerializer(customSerializer) {
if (customSerializer === reqSerializers.reqSerializer) return customSerializer;
return /* @__PURE__ */ __name(function wrappedReqSerializer(req) {
return customSerializer(reqSerializers.reqSerializer(req));
}, "wrappedReqSerializer");
}, "wrapRequestSerializer"),
wrapResponseSerializer: /* @__PURE__ */ __name(function wrapResponseSerializer(customSerializer) {
if (customSerializer === resSerializers.resSerializer) return customSerializer;
return /* @__PURE__ */ __name(function wrappedResSerializer(res) {
return customSerializer(resSerializers.resSerializer(res));
}, "wrappedResSerializer");
}, "wrapResponseSerializer")
};
}
});
// node_modules/pino/lib/caller.js
var require_caller = __commonJS({
"node_modules/pino/lib/caller.js"(exports2, module2) {
"use strict";
function noOpPrepareStackTrace(_, stack) {
return stack;
}
__name(noOpPrepareStackTrace, "noOpPrepareStackTrace");
module2.exports = /* @__PURE__ */ __name(function getCallers() {
const originalPrepare = Error.prepareStackTrace;
Error.prepareStackTrace = noOpPrepareStackTrace;
const stack = new Error().stack;
Error.prepareStackTrace = originalPrepare;
if (!Array.isArray(stack)) {
return void 0;
}
const entries = stack.slice(2);
const fileNames = [];
for (const entry of entries) {
if (!entry) {
continue;
}
fileNames.push(entry.getFileName());
}
return fileNames;
}, "getCallers");
}
});
// node_modules/fast-redact/lib/validator.js
var require_validator = __commonJS({
"node_modules/fast-redact/lib/validator.js"(exports2, module2) {
"use strict";
module2.exports = validator;
function validator(opts = {}) {
const { ERR_PATHS_MUST_BE_STRINGS = /* @__PURE__ */ __name(() => "fast-redact - Paths must be (non-empty) strings", "ERR_PATHS_MUST_BE_STRINGS"), ERR_INVALID_PATH = /* @__PURE__ */ __name((s) => `fast-redact \u2013 Invalid path (${s})`, "ERR_INVALID_PATH") } = opts;
return /* @__PURE__ */ __name(function validate({ paths }) {
paths.forEach((s) => {
if (typeof s !== "string") {
throw Error(ERR_PATHS_MUST_BE_STRINGS());
}
try {
if (/〇/.test(s)) throw Error();
const expr = (s[0] === "[" ? "" : ".") + s.replace(/^\*/, "\u3007").replace(/\.\*/g, ".\u3007").replace(/\[\*\]/g, "[\u3007]");
if (/\n|\r|;/.test(expr)) throw Error();
if (/\/\*/.test(expr)) throw Error();
Function(`
'use strict'
const o = new Proxy({}, { get: () => o, set: () => { throw Error() } });
const \u3007 = null;
o${expr}
if ([o${expr}].length !== 1) throw Error()`)();
} catch (e) {
throw Error(ERR_INVALID_PATH(s));
}
});
}, "validate");
}
__name(validator, "validator");
}
});
// node_modules/fast-redact/lib/rx.js
var require_rx = __commonJS({
"node_modules/fast-redact/lib/rx.js"(exports2, module2) {
"use strict";
module2.exports = /[^.[\]]+|\[((?:.)*?)\]/g;
}
});
// node_modules/fast-redact/lib/parse.js
var require_parse = __commonJS({
"node_modules/fast-redact/lib/parse.js"(exports2, module2) {
"use strict";
var rx = require_rx();
module2.exports = parse;
function parse({ paths }) {
const wildcards = [];
var wcLen = 0;
const secret = paths.reduce(function(o, strPath, ix) {
var path = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
const leadingBracket = strPath[0] === "[";
path = path.map((p) => {
if (p[0] === "[") return p.substr(1, p.length - 2);
else return p;
});
const star = path.indexOf("*");
if (star > -1) {
const before = path.slice(0, star);
const beforeStr = before.join(".");
const after = path.slice(star + 1, path.length);
const nested = after.length > 0;
wcLen++;
wildcards.push({
before,
beforeStr,
after,
nested
});
} else {
o[strPath] = {
path,
val: void 0,
precensored: false,
circle: "",
escPath: JSON.stringify(strPath),
leadingBracket
};
}
return o;
}, {});
return {
wildcards,
wcLen,
secret
};
}
__name(parse, "parse");
}
});
// node_modules/fast-redact/lib/redactor.js
var require_redactor = __commonJS({
"node_modules/fast-redact/lib/redactor.js"(exports2, module2) {
"use strict";
var rx = require_rx();
module2.exports = redactor;
function redactor({ secret, serialize, wcLen, strict, isCensorFct, censorFctTakesPath }, state) {
const redact = Function("o", `
if (typeof o !== 'object' || o == null) {
${strictImpl(strict, serialize)}
}
const { censor, secret } = this
const originalSecret = {}
const secretKeys = Object.keys(secret)
for (var i = 0; i < secretKeys.length; i++) {
originalSecret[secretKeys[i]] = secret[secretKeys[i]]
}
${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
this.compileRestore()
${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
this.secret = originalSecret
${resultTmpl(serialize)}
`).bind(state);
redact.state = state;
if (serialize === false) {
redact.restore = (o) => state.restore(o);
}
return redact;
}
__name(redactor, "redactor");
function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
return Object.keys(secret).map((path) => {
const { escPath, leadingBracket, path: arrPath } = secret[path];
const skip = leadingBracket ? 1 : 0;
const delim = leadingBracket ? "" : ".";
const hops = [];
var match;
while ((match = rx.exec(path)) !== null) {
const [, ix] = match;
const { index, input } = match;
if (index > skip) hops.push(input.substring(0, index - (ix ? 0 : 1)));
}
var existence = hops.map((p) => `o${delim}${p}`).join(" && ");
if (existence.length === 0) existence += `o${delim}${path} != null`;
else existence += ` && o${delim}${path} != null`;
const circularDetection = `
switch (true) {
${hops.reverse().map((p) => `
case o${delim}${p} === censor:
secret[${escPath}].circle = ${JSON.stringify(p)}
break
`).join("\n")}
}
`;
const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : `val`;
return `
if (${existence}) {
const val = o${delim}${path}
if (val === censor) {
secret[${escPath}].precensored = true
} else {
secret[${escPath}].val = val
o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
${circularDetection}
}
}
`;
}).join("\n");
}
__name(redactTmpl, "redactTmpl");
function dynamicRedactTmpl(hasWildcards, isCensorFct, censorFctTakesPath) {
return hasWildcards === true ? `
{
const { wildcards, wcLen, groupRedact, nestedRedact } = this
for (var i = 0; i < wcLen; i++) {
const { before, beforeStr, after, nested } = wildcards[i]
if (nested === true) {
secret[beforeStr] = secret[beforeStr] || []
nestedRedact(secret[beforeStr], o, before, after, censor, ${isCensorFct}, ${censorFctTakesPath})
} else secret[beforeStr] = groupRedact(o, before, censor, ${isCensorFct}, ${censorFctTakesPath})
}
}
` : "";
}
__name(dynamicRedactTmpl, "dynamicRedactTmpl");
function resultTmpl(serialize) {
return serialize === false ? `return o` : `
var s = this.serialize(o)
this.restore(o)
return s
`;
}
__name(resultTmpl, "resultTmpl");
function strictImpl(strict, serialize) {
return strict === true ? `throw Error('fast-redact: primitives cannot be redacted')` : serialize === false ? `return o` : `return this.serialize(o)`;
}
__name(strictImpl, "strictImpl");
}
});
// node_modules/fast-redact/lib/modifiers.js
var require_modifiers = __commonJS({
"node_modules/fast-redact/lib/modifiers.js"(exports2, module2) {
"use strict";
module2.exports = {
groupRedact,
groupRestore,
nestedRedact,
nestedRestore
};
function groupRestore({ keys, values, target }) {
if (target == null || typeof target === "string") return;
const length = keys.length;
for (var i = 0; i < length; i++) {
const k = keys[i];
target[k] = values[i];
}
}
__name(groupRestore, "groupRestore");
function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
const target = get(o, path);
if (target == null || typeof target === "string") return {
keys: null,
values: null,
target,
flat: true
};
const keys = Object.keys(target);
const keysLength = keys.length;
const pathLength = path.length;
const pathWithKey = censorFctTakesPath ? [
...path
] : void 0;
const values = new Array(keysLength);
for (var i = 0; i < keysLength; i++) {
const key = keys[i];
values[i] = target[key];
if (censorFctTakesPath) {
pathWithKey[pathLength] = key;
target[key] = censor(target[key], pathWithKey);
} else if (isCensorFct) {
target[key] = censor(target[key]);
} else {
target[key] = censor;
}
}
return {
keys,
values,
target,
flat: true
};
}
__name(groupRedact, "groupRedact");
function nestedRestore(instructions) {
for (let i = 0; i < instructions.length; i++) {
const { target, path, value } = instructions[i];
let current = target;
for (let i2 = path.length - 1; i2 > 0; i2--) {
current = current[path[i2]];
}
current[path[0]] = value;
}
}
__name(nestedRestore, "nestedRestore");
function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
const target = get(o, path);
if (target == null) return;
const keys = Object.keys(target);
const keysLength = keys.length;
for (var i = 0; i < keysLength; i++) {
const key = keys[i];
specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
}
return store;
}
__name(nestedRedact, "nestedRedact");
function has(obj, prop) {
return obj !== void 0 && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
}
__name(has, "has");
function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
const afterPathLen = afterPath.length;
const lastPathIndex = afterPathLen - 1;
const originalKey = k;
var i = -1;
var n;
var nv;
var ov;
var oov = null;
var wc = null;
var kIsWc;
var wcov;
var consecutive = false;
var level = 0;
var depth = 0;
var redactPathCurrent = tree();
ov = n = o[k];
if (typeof n !== "object") return;
while (n != null && ++i < afterPathLen) {
depth += 1;
k = afterPath[i];
oov = ov;
if (k !== "*" && !wc && !(typeof n === "object" && k in n)) {
break;
}
if (k === "*") {
if (wc === "*") {
consecutive = true;
}
wc = k;
if (i !== lastPathIndex) {
continue;
}
}
if (wc) {
const wcKeys = Object.keys(n);
for (var j = 0; j < wcKeys.length; j++) {
const wck = wcKeys[j];
wcov = n[wck];
kIsWc = k === "*";
if (consecutive) {
redactPathCurrent = node(redactPathCurrent, wck, depth);
level = i;
ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
} else {
if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
if (kIsWc) {
ov = wcov;
} else {
ov = wcov[k];
}
nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
...path,
originalKey,
...afterPath
]) : censor(ov) : censor;
if (kIsWc) {
const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
store.push(rv);
n[wck] = nv;
} else {
if (wcov[k] === nv) {
} else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
redactPathCurrent = node(redactPathCurrent, wck, depth);
} else {
redactPathCurrent = node(redactPathCurrent, wck, depth);
const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey]);
store.push(rv);
wcov[k] = nv;
}
}
}
}
}
wc = null;
} else {
ov = n[k];
redactPathCurrent = node(redactPathCurrent, k, depth);
nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
...path,
originalKey,
...afterPath
]) : censor(ov) : censor;
if (has(n, k) && nv === ov || nv === void 0 && censor !== void 0) {
} else {
const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
store.push(rv);
n[k] = nv;
}
n = n[k];
}
if (typeof n !== "object") break;
if (ov === oov || typeof ov === "undefined") {
}
}
}
__name(specialSet, "specialSet");
function get(o, p) {
var i = -1;
var l = p.length;
var n = o;
while (n != null && ++i < l) {
n = n[p[i]];
}
return n;
}
__name(get, "get");
function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
if (level === 0) {
if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
if (kIsWc) {
ov = wcov;
} else {
ov = wcov[k];
}
nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
...path,
originalKey,
...afterPath
]) : censor(ov) : censor;
if (kIsWc) {
const rv = restoreInstr(redactPathCurrent, ov, parent);
store.push(rv);
n[wck] = nv;
} else {
if (wcov[k] === nv) {
} else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
} else {
const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent);
store.push(rv);
wcov[k] = nv;
}
}
}
}
for (const key in wcov) {
if (typeof wcov[key] === "object") {
redactPathCurrent = node(redactPathCurrent, key, depth);
iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
}
}
}
__name(iterateNthLevel, "iterateNthLevel");
function tree() {
return {
parent: null,
key: null,
children: [],
depth: 0
};
}
__name(tree, "tree");
function node(parent, key, depth) {
if (parent.depth === depth) {
return node(parent.parent, key, depth);
}
var child = {
parent,
key,
depth,
children: []
};
parent.children.push(child);
return child;
}
__name(node, "node");
function restoreInstr(node2, value, target) {
let current = node2;
const path = [];
do {
path.push(current.key);
current = current.parent;
} while (current.parent != null);
return {
path,
value,
target
};
}
__name(restoreInstr, "restoreInstr");
}
});
// node_modules/fast-redact/lib/restorer.js
var require_restorer = __commonJS({
"node_modules/fast-redact/lib/restorer.js"(exports2, module2) {
"use strict";
var { groupRestore, nestedRestore } = require_modifiers();
module2.exports = restorer;
function restorer() {
return /* @__PURE__ */ __name(function compileRestore() {
if (this.restore) {
this.restore.state.secret = this.secret;
return;
}
const { secret, wcLen } = this;
const paths = Object.keys(secret);
const resetters = resetTmpl(secret, paths);
const hasWildcards = wcLen > 0;
const state = hasWildcards ? {
secret,
groupRestore,
nestedRestore
} : {
secret
};
this.restore = Function("o", restoreTmpl(resetters, paths, hasWildcards)).bind(state);
this.restore.state = state;
}, "compileRestore");
}
__name(restorer, "restorer");
function resetTmpl(secret, paths) {
return paths.map((path) => {
const { circle, escPath, leadingBracket } = secret[path];
const delim = leadingBracket ? "" : ".";
const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path} = secret[${escPath}].val`;
const clear = `secret[${escPath}].val = undefined`;
return `
if (secret[${escPath}].val !== undefined) {
try { ${reset} } catch (e) {}
${clear}
}
`;
}).join("");
}
__name(resetTmpl, "resetTmpl");
function restoreTmpl(resetters, paths, hasWildcards) {
const dynamicReset = hasWildcards === true ? `
const keys = Object.keys(secret)
const len = keys.length
for (var i = len - 1; i >= ${paths.length}; i--) {
const k = keys[i]
const o = secret[k]
if (o) {
if (o.flat === true) this.groupRestore(o)
else this.nestedRestore(o)
secret[k] = null
}
}
` : "";
return `
const secret = this.secret
${dynamicReset}
${resetters}
return o
`;
}
__name(restoreTmpl, "restoreTmpl");
}
});
// node_modules/fast-redact/lib/state.js
var require_state = __commonJS({
"node_modules/fast-redact/lib/state.js"(exports2, module2) {
"use strict";
module2.exports = state;
function state(o) {
const { secret, censor, compileRestore, serialize, groupRedact, nestedRedact, wildcards, wcLen } = o;
const builder = [
{
secret,
censor,
compileRestore
}
];
if (serialize !== false) builder.push({
serialize
});
if (wcLen > 0) builder.push({
groupRedact,
nestedRedact,
wildcards,
wcLen
});
return Object.assign(...builder);
}
__name(state, "state");
}
});
// node_modules/fast-redact/index.js
var require_fast_redact = __commonJS({
"node_modules/fast-redact/index.js"(exports2, module2) {
"use strict";
var validator = require_validator();
var parse = require_parse();
var redactor = require_redactor();
var restorer = require_restorer();
var { groupRedact, nestedRedact } = require_modifiers();
var state = require_state();
var rx = require_rx();
var validate = validator();
var noop = /* @__PURE__ */ __name((o) => o, "noop");
noop.restore = noop;
var DEFAULT_CENSOR = "[REDACTED]";
fastRedact.rx = rx;
fastRedact.validator = validator;
module2.exports = fastRedact;
function fastRedact(opts = {}) {
const paths = Array.from(new Set(opts.paths || []));
const serialize = "serialize" in opts ? opts.serialize === false ? opts.serialize : typeof opts.serialize === "function" ? opts.serialize : JSON.stringify : JSON.stringify;
const remove = opts.remove;
if (remove === true && serialize !== JSON.stringify) {
throw Error("fast-redact \u2013 remove option may only be set when serializer is JSON.stringify");
}
const censor = remove === true ? void 0 : "censor" in opts ? opts.censor : DEFAULT_CENSOR;
const isCensorFct = typeof censor === "function";
const censorFctTakesPath = isCensorFct && censor.length > 1;
if (paths.length === 0) return serialize || noop;
validate({
paths,
serialize,
censor
});
const { wildcards, wcLen, secret } = parse({
paths,
censor
});
const compileRestore = restorer();
const strict = "strict" in opts ? opts.strict : true;
return redactor({
secret,
wcLen,
serialize,
strict,
isCensorFct,
censorFctTakesPath
}, state({
secret,
censor,
compileRestore,
serialize,
groupRedact,
nestedRedact,
wildcards,
wcLen
}));
}
__name(fastRedact, "fastRedact");
}
});
// node_modules/pino/lib/symbols.js
var require_symbols = __commonJS({
"node_modules/pino/lib/symbols.js"(exports2, module2) {
"use strict";
var setLevelSym = Symbol("pino.setLevel");
var getLevelSym = Symbol("pino.getLevel");
var levelValSym = Symbol("pino.levelVal");
var levelCompSym = Symbol("pino.levelComp");
var useLevelLabelsSym = Symbol("pino.useLevelLabels");
var useOnlyCustomLevelsSym = Symbol("pino.useOnlyCustomLevels");
var mixinSym = Symbol("pino.mixin");
var lsCacheSym = Symbol("pino.lsCache");
var chindingsSym = Symbol("pino.chindings");
var asJsonSym = Symbol("pino.asJson");
var writeSym = Symbol("pino.write");
var redactFmtSym = Symbol("pino.redactFmt");
var timeSym = Symbol("pino.time");
var timeSliceIndexSym = Symbol("pino.timeSliceIndex");
var streamSym = Symbol("pino.stream");
var stringifySym = Symbol("pino.stringify");
var stringifySafeSym = Symbol("pino.stringifySafe");
var stringifiersSym = Symbol("pino.stringifiers");
var endSym = Symbol("pino.end");
var formatOptsSym = Symbol("pino.formatOpts");
var messageKeySym = Symbol("pino.messageKey");
var errorKeySym = Symbol("pino.errorKey");
var nestedKeySym = Symbol("pino.nestedKey");
var nestedKeyStrSym = Symbol("pino.nestedKeyStr");
var mixinMergeStrategySym = Symbol("pino.mixinMergeStrategy");
var msgPrefixSym = Symbol("pino.msgPrefix");
var wildcardFirstSym = Symbol("pino.wildcardFirst");
var serializersSym = Symbol.for("pino.serializers");
var formattersSym = Symbol.for("pino.formatters");
var hooksSym = Symbol.for("pino.hooks");
var needsMetadataGsym = Symbol.for("pino.metadata");
module2.exports = {
setLevelSym,
getLevelSym,
levelValSym,
levelCompSym,
useLevelLabelsSym,
mixinSym,
lsCacheSym,
chindingsSym,
asJsonSym,
writeSym,
serializersSym,
redactFmtSym,
timeSym,
timeSliceIndexSym,
streamSym,
stringifySym,
stringifySafeSym,
stringifiersSym,
endSym,
formatOptsSym,
messageKeySym,
errorKeySym,
nestedKeySym,
wildcardFirstSym,
needsMetadataGsym,
useOnlyCustomLevelsSym,
formattersSym,
hooksSym,
nestedKeyStrSym,
mixinMergeStrategySym,
msgPrefixSym
};
}
});
// node_modules/pino/lib/redaction.js
var require_redaction = __commonJS({
"node_modules/pino/lib/redaction.js"(exports2, module2) {
"use strict";
var fastRedact = require_fast_redact();
var { redactFmtSym, wildcardFirstSym } = require_symbols();
var { rx, validator } = fastRedact;
var validate = validator({
ERR_PATHS_MUST_BE_STRINGS: /* @__PURE__ */ __name(() => "pino \u2013 redacted paths must be strings", "ERR_PATHS_MUST_BE_STRINGS"),
ERR_INVALID_PATH: /* @__PURE__ */ __name((s) => `pino \u2013 redact paths array contains an invalid path (${s})`, "ERR_INVALID_PATH")
});
var CENSOR = "[Redacted]";
var strict = false;
function redaction(opts, serialize) {
const { paths, censor } = handle(opts);
const shape = paths.reduce((o, str) => {
rx.lastIndex = 0;
const first = rx.exec(str);
const next = rx.exec(str);
let ns = first[1] !== void 0 ? first[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, "$1") : first[0];
if (ns === "*") {
ns = wildcardFirstSym;
}
if (next === null) {
o[ns] = null;
return o;
}
if (o[ns] === null) {
return o;
}
const { index } = next;
const nextPath = `${str.substr(index, str.length - 1)}`;
o[ns] = o[ns] || [];
if (ns !== wildcardFirstSym && o[ns].length === 0) {
o[ns].push(...o[wildcardFirstSym] || []);
}
if (ns === wildcardFirstSym) {
Object.keys(o).forEach(function(k) {
if (o[k]) {
o[k].push(nextPath);
}
});
}
o[ns].push(nextPath);
return o;
}, {});
const result = {
[redactFmtSym]: fastRedact({
paths,
censor,
serialize,
strict
})
};
const topCensor = /* @__PURE__ */ __name((...args) => {
return typeof censor === "function" ? serialize(censor(...args)) : serialize(censor);
}, "topCensor");
return [
...Object.keys(shape),
...Object.getOwnPropertySymbols(shape)
].reduce((o, k) => {
if (shape[k] === null) {
o[k] = (value) => topCensor(value, [
k
]);
} else {
const wrappedCensor = typeof censor === "function" ? (value, path) => {
return censor(value, [
k,
...path
]);
} : censor;
o[k] = fastRedact({
paths: shape[k],
censor: wrappedCensor,
serialize,
strict
});
}
return o;
}, result);
}
__name(redaction, "redaction");
function handle(opts) {
if (Array.isArray(opts)) {
opts = {
paths: opts,
censor: CENSOR
};
validate(opts);
return opts;
}
let { paths, censor = CENSOR, remove } = opts;
if (Array.isArray(paths) === false) {
throw Error("pino \u2013 redact must contain an array of strings");
}
if (remove === true) censor = void 0;
validate({
paths,
censor
});
return {
paths,
censor
};
}
__name(handle, "handle");
module2.exports = redaction;
}
});
// node_modules/pino/lib/time.js
var require_time = __commonJS({
"node_modules/pino/lib/time.js"(exports2, module2) {
"use strict";
var nullTime = /* @__PURE__ */ __name(() => "", "nullTime");
var epochTime = /* @__PURE__ */ __name(() => `,"time":${Date.now()}`, "epochTime");
var unixTime = /* @__PURE__ */ __name(() => `,"time":${Math.round(Date.now() / 1e3)}`, "unixTime");
var isoTime = /* @__PURE__ */ __name(() => `,"time":"${new Date(Date.now()).toISOString()}"`, "isoTime");
var NS_PER_MS = 1000000n;
var NS_PER_SEC = 1000000000n;
var startWallTimeNs = BigInt(Date.now()) * NS_PER_MS;
var startHrTime = process.hrtime.bigint();
var isoTimeNano = /* @__PURE__ */ __name(() => {
const elapsedNs = process.hrtime.bigint() - startHrTime;
const currentTimeNs = startWallTimeNs + elapsedNs;
const secondsSinceEpoch = currentTimeNs / NS_PER_SEC;
const nanosWithinSecond = currentTimeNs % NS_PER_SEC;
const msSinceEpoch = Number(secondsSinceEpoch * 1000n + nanosWithinSecond / 1000000n);
const date = new Date(msSinceEpoch);
const year = date.getUTCFullYear();
const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
const day = date.getUTCDate().toString().padStart(2, "0");
const hours = date.getUTCHours().toString().padStart(2, "0");
const minutes = date.getUTCMinutes().toString().padStart(2, "0");
const seconds = date.getUTCSeconds().toString().padStart(2, "0");
return `,"time":"${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${nanosWithinSecond.toString().padStart(9, "0")}Z"`;
}, "isoTimeNano");
module2.exports = {
nullTime,
epochTime,
unixTime,
isoTime,
isoTimeNano
};
}
});
// node_modules/quick-format-unescaped/index.js
var require_quick_format_unescaped = __commonJS({
"node_modules/quick-format-unescaped/index.js"(exports2, module2) {
"use strict";
function tryStringify(o) {
try {
return JSON.stringify(o);
} catch (e) {
return '"[Circular]"';
}
}
__name(tryStringify, "tryStringify");
module2.exports = format4;
function format4(f, args, opts) {
var ss = opts && opts.stringify || tryStringify;
var offset = 1;
if (typeof f === "object" && f !== null) {
var len = args.length + offset;
if (len === 1) return f;
var objects = new Array(len);
objects[0] = ss(f);
for (var index = 1; index < len; index++) {
objects[index] = ss(args[index]);
}
return objects.join(" ");
}
if (typeof f !== "string") {
return f;
}
var argLen = args.length;
if (argLen === 0) return f;
var str = "";
var a = 1 - offset;
var lastPos = -1;
var flen = f && f.length || 0;
for (var i = 0; i < flen; ) {
if (f.charCodeAt(i) === 37 && i + 1 < flen) {
lastPos = lastPos > -1 ? lastPos : 0;
switch (f.charCodeAt(i + 1)) {
case 100:
case 102:
if (a >= argLen) break;
if (args[a] == null) break;
if (lastPos < i) str += f.slice(lastPos, i);
str += Number(args[a]);
lastPos = i + 2;
i++;
break;
case 105:
if (a >= argLen) break;
if (args[a] == null) break;
if (lastPos < i) str += f.slice(lastPos, i);
str += Math.floor(Number(args[a]));
lastPos = i + 2;
i++;
break;
case 79:
case 111:
case 106:
if (a >= argLen) break;
if (args[a] === void 0) break;
if (lastPos < i) str += f.slice(lastPos, i);
var type = typeof args[a];
if (type === "string") {
str += "'" + args[a] + "'";
lastPos = i + 2;
i++;
break;
}
if (type === "function") {
str += args[a].name || "<anonymous>";
lastPos = i + 2;
i++;
break;
}
str += ss(args[a]);
lastPos = i + 2;
i++;
break;
case 115:
if (a >= argLen) break;
if (lastPos < i) str += f.slice(lastPos, i);
str += String(args[a]);
lastPos = i + 2;
i++;
break;
case 37:
if (lastPos < i) str += f.slice(lastPos, i);
str += "%";
lastPos = i + 2;
i++;
a--;
break;
}
++a;
}
++i;
}
if (lastPos === -1) return f;
else if (lastPos < flen) {
str += f.slice(lastPos);
}
return str;
}
__name(format4, "format");
}
});
// node_modules/atomic-sleep/index.js
var require_atomic_sleep = __commonJS({
"node_modules/atomic-sleep/index.js"(exports2, module2) {
"use strict";
if (typeof SharedArrayBuffer !== "undefined" && typeof Atomics !== "undefined") {
let sleep = function(ms) {
const valid = ms > 0 && ms < Infinity;
if (valid === false) {
if (typeof ms !== "number" && typeof ms !== "bigint") {
throw TypeError("sleep: ms must be a number");
}
throw RangeError("sleep: ms must be a number that is greater than 0 but less than Infinity");
}
Atomics.wait(nil, 0, 0, Number(ms));
};
__name(sleep, "sleep");
const nil = new Int32Array(new SharedArrayBuffer(4));
module2.exports = sleep;
} else {
let sleep1 = function(ms) {
const valid = ms > 0 && ms < Infinity;
if (valid === false) {
if (typeof ms !== "number" && typeof ms !== "bigint") {
throw TypeError("sleep: ms must be a number");
}
throw RangeError("sleep: ms must be a number that is greater than 0 but less than Infinity");
}
const target = Date.now() + Number(ms);
while (target > Date.now()) {
}
};
__name(sleep1, "sleep1");
module2.exports = sleep1;
}
}
});
// node_modules/sonic-boom/index.js
var require_sonic_boom = __commonJS({
"node_modules/sonic-boom/index.js"(exports2, module2) {
"use strict";
var fs = require("fs");
var EventEmitter = require("events");
var inherits = require("util").inherits;
var path = require("path");
var sleep = require_atomic_sleep();
var assert = require("assert");
var BUSY_WRITE_TIMEOUT = 100;
var kEmptyBuffer = Buffer.allocUnsafe(0);
var MAX_WRITE = 16 * 1024;
var kContentModeBuffer = "buffer";
var kContentModeUtf8 = "utf8";
var [major, minor] = (process.versions.node || "0.0").split(".").map(Number);
var kCopyBuffer = major >= 22 && minor >= 7;
function openFile(file, sonic) {
sonic._opening = true;
sonic._writing = true;
sonic._asyncDrainScheduled = false;
function fileOpened(err, fd) {
if (err) {
sonic._reopening = false;
sonic._writing = false;
sonic._opening = false;
if (sonic.sync) {
process.nextTick(() => {
if (sonic.listenerCount("error") > 0) {
sonic.emit("error", err);
}
});
} else {
sonic.emit("error", err);
}
return;
}
const reopening = sonic._reopening;
sonic.fd = fd;
sonic.file = file;
sonic._reopening = false;
sonic._opening = false;
sonic._writing = false;
if (sonic.sync) {
process.nextTick(() => sonic.emit("ready"));
} else {
sonic.emit("ready");
}
if (sonic.destroyed) {
return;
}
if (!sonic._writing && sonic._len > sonic.minLength || sonic._flushPending) {
sonic._actualWrite();
} else if (reopening) {
process.nextTick(() => sonic.emit("drain"));
}
}
__name(fileOpened, "fileOpened");
const flags = sonic.append ? "a" : "w";
const mode = sonic.mode;
if (sonic.sync) {
try {
if (sonic.mkdir) fs.mkdirSync(path.dirname(file), {
recursive: true
});
const fd = fs.openSync(file, flags, mode);
fileOpened(null, fd);
} catch (err) {
fileOpened(err);
throw err;
}
} else if (sonic.mkdir) {
fs.mkdir(path.dirname(file), {
recursive: true
}, (err) => {
if (err) return fileOpened(err);
fs.open(file, flags, mode, fileOpened);
});
} else {
fs.open(file, flags, mode, fileOpened);
}
}
__name(openFile, "openFile");
function SonicBoom(opts) {
if (!(this instanceof SonicBoom)) {
return new SonicBoom(opts);
}
let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
fd = fd || dest;
this._len = 0;
this.fd = -1;
this._bufs = [];
this._lens = [];
this._writing = false;
this._ending = false;
this._reopening = false;
th