@gemini-dock/server
Version:
An extensible Gemini server written in TypeScript
1,460 lines (1,436 loc) • 146 kB
JavaScript
#!/usr/bin/env node
"use strict";
var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js
var require_err_helpers = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js"(exports2, module2) {
"use strict";
var isErrorLike = (err) => {
return err && typeof err.message === "string";
};
var getErrorCause = (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;
}
};
var _stackWithCauses = (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;
}
};
var stackWithCauses = (err) => _stackWithCauses(err, /* @__PURE__ */ new Set());
var _messageWithCauses = (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;
}
};
var messageWithCauses = (err) => _messageWithCauses(err, /* @__PURE__ */ new Set());
module2.exports = {
isErrorLike,
getErrorCause,
stackWithCauses,
messageWithCauses
};
}
});
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js
var require_err_proto = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/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: function() {
return this[rawSymbol];
},
set: function(val) {
this[rawSymbol] = val;
}
}
});
Object.defineProperty(pinoErrProto, rawSymbol, {
writable: true,
value: {}
});
module2.exports = {
pinoErrProto,
pinoErrorSymbols: {
seen,
rawSymbol
}
};
}
});
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err.js
var require_err = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/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;
}
}
});
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-with-cause.js
var require_err_with_cause = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/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;
}
}
});
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/req.js
var require_req = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/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: function() {
return this[rawSymbol];
},
set: function(val) {
this[rawSymbol] = val;
}
}
});
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;
}
function mapHttpRequest(req) {
return {
req: reqSerializer(req)
};
}
}
});
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/res.js
var require_res = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/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: function() {
return this[rawSymbol];
},
set: function(val) {
this[rawSymbol] = val;
}
}
});
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;
}
function mapHttpResponse(res) {
return {
res: resSerializer(res)
};
}
}
});
// ../../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js
var require_pino_std_serializers = __commonJS({
"../../../node_modules/.pnpm/pino-std-serializers@7.0.0/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: function wrapErrorSerializer(customSerializer) {
if (customSerializer === errSerializer) return customSerializer;
return function wrapErrSerializer(err) {
return customSerializer(errSerializer(err));
};
},
wrapRequestSerializer: function wrapRequestSerializer(customSerializer) {
if (customSerializer === reqSerializers.reqSerializer) return customSerializer;
return function wrappedReqSerializer(req) {
return customSerializer(reqSerializers.reqSerializer(req));
};
},
wrapResponseSerializer: function wrapResponseSerializer(customSerializer) {
if (customSerializer === resSerializers.resSerializer) return customSerializer;
return function wrappedResSerializer(res) {
return customSerializer(resSerializers.resSerializer(res));
};
}
};
}
});
// ../../../node_modules/.pnpm/pino@9.6.0/node_modules/pino/lib/caller.js
var require_caller = __commonJS({
"../../../node_modules/.pnpm/pino@9.6.0/node_modules/pino/lib/caller.js"(exports2, module2) {
"use strict";
function noOpPrepareStackTrace(_, stack) {
return stack;
}
module2.exports = 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;
};
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/validator.js
var require_validator = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/validator.js"(exports2, module2) {
"use strict";
module2.exports = validator;
function validator(opts = {}) {
const {
ERR_PATHS_MUST_BE_STRINGS = () => "fast-redact - Paths must be (non-empty) strings",
ERR_INVALID_PATH = (s) => `fast-redact \u2013 Invalid path (${s})`
} = opts;
return 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));
}
});
};
}
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/rx.js
var require_rx = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/rx.js"(exports2, module2) {
"use strict";
module2.exports = /[^.[\]]+|\[((?:.)*?)\]/g;
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/parse.js
var require_parse = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/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 };
}
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/redactor.js
var require_redactor = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/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;
}
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");
}
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})
}
}
` : "";
}
function resultTmpl(serialize) {
return serialize === false ? `return o` : `
var s = this.serialize(o)
this.restore(o)
return s
`;
}
function strictImpl(strict, serialize) {
return strict === true ? `throw Error('fast-redact: primitives cannot be redacted')` : serialize === false ? `return o` : `return this.serialize(o)`;
}
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/modifiers.js
var require_modifiers = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/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];
}
}
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 };
}
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;
}
}
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;
}
function has(obj, prop) {
return obj !== void 0 && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
}
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") {
}
}
}
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;
}
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);
}
}
}
function tree() {
return { parent: null, key: null, children: [], depth: 0 };
}
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;
}
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 };
}
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/restorer.js
var require_restorer = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/restorer.js"(exports2, module2) {
"use strict";
var { groupRestore, nestedRestore } = require_modifiers();
module2.exports = restorer;
function restorer() {
return 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;
};
}
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("");
}
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
`;
}
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/state.js
var require_state = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/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);
}
}
});
// ../../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/index.js
var require_fast_redact = __commonJS({
"../../../node_modules/.pnpm/fast-redact@3.5.0/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 = (o) => o;
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
}));
}
}
});
// ../../../node_modules/.pnpm/pino@9.6.0/node_modules/pino/lib/symbols.js
var require_symbols = __commonJS({
"../../../node_modules/.pnpm/pino@9.6.0/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/.pnpm/pino@9.6.0/node_modules/pino/lib/redaction.js
var require_redaction = __commonJS({
"../../../node_modules/.pnpm/pino@9.6.0/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: () => "pino \u2013 redacted paths must be strings",
ERR_INVALID_PATH: (s) => `pino \u2013 redact paths array contains an invalid path (${s})`
});
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 = (...args) => {
return typeof censor === "function" ? serialize(censor(...args)) : serialize(censor);
};
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);
}
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 };
}
module2.exports = redaction;
}
});
// ../../../node_modules/.pnpm/pino@9.6.0/node_modules/pino/lib/time.js
var require_time = __commonJS({
"../../../node_modules/.pnpm/pino@9.6.0/node_modules/pino/lib/time.js"(exports2, module2) {
"use strict";
var nullTime = () => "";
var epochTime = () => `,"time":${Date.now()}`;
var unixTime = () => `,"time":${Math.round(Date.now() / 1e3)}`;
var isoTime = () => `,"time":"${new Date(Date.now()).toISOString()}"`;
module2.exports = { nullTime, epochTime, unixTime, isoTime };
}
});
// ../../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js
var require_quick_format_unescaped = __commonJS({
"../../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js"(exports2, module2) {
"use strict";
function tryStringify(o) {
try {
return JSON.stringify(o);
} catch (e) {
return '"[Circular]"';
}
}
module2.exports = format;
function format(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:
// 'd'
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:
// 'O'
case 111:
// 'o'
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;
}
}
});
// ../../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js
var require_atomic_sleep = __commonJS({
"../../../node_modules/.pnpm/atomic-sleep@1.0.0/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));
};
const nil = new Int32Array(new SharedArrayBuffer(4));
module2.exports = sleep;
} else {
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");
}
const target = Date.now() + Number(ms);
while (target > Date.now()) {
}
};
module2.exports = sleep;
}
}
});
// ../../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js
var require_sonic_boom = __commonJS({
"../../../node_modules/.pnpm/sonic-boom@4.2.0/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"));
}
}
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);
}
}
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;
this._asyncDrainScheduled = false;
this._flushPending = false;
this._hwm = Math.max(minLength || 0, 16387);
this.file = null;
this.destroyed = false;
this.minLength = minLength || 0;
this.maxLength = maxLength || 0;
this.maxWrite = maxWrite || MAX_WRITE;
this._periodicFlush = periodicFlush || 0;
this._periodicFlushTimer = void 0;
this.sync = sync || false;
this.writable = true;
this._fsync = fsync || false;
this.append = append || false;
this.mode = mode;
this.retryEAGAIN = retryEAGAIN || (() => true);
this.mkdir = mkdir || false;
let fsWriteSync;
let fsWrite;
if (contentMode === kContentModeBuffer) {
this._writingBuf = kEmptyBuffer;
this.write = writeBuffer;
this.flush = flushBuffer;
this.flushSync = flushBufferSync;
this._actualWrite = actualWriteBuffer;
fsWriteSync = () => fs.writeSync(this.fd, this._writingBuf);
fsWrite = () => fs.write(this.fd, this._writingBuf, this.release);
} else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
this._writingBuf = "";
this.write = write;
this.flush = flush;
this.flushSync = flushSync;
this._actualWrite = actualWrite;
fsWriteSync = () => fs.writeSync(this.fd, this._writingBuf, "utf8");
fsWrite = () => fs.write(this.fd, this._writingBuf, "utf8", this.release);
} else {
throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
}
if (typeof fd === "number") {
this.fd = fd;
process.nextTick(() => this.emit("ready"));
} else if (typeof fd === "string") {
openFile(fd, this);
} else {
throw new Error("SonicBoom supports only file descriptors and files");
}
if (this.minLength >= this.maxWrite) {
throw new Error(`minLength should be smaller than maxWrite (${this.maxWrite})`);
}
this.release = (err, n) => {
if (err) {
if ((err.code === "EAGAIN" || err.code === "EBUSY") && this.retryEAGAIN(err, this._writingBuf.length, this._len - this._writingBuf.length)) {
if (this.sync) {
try {
sleep(BUSY_WRITE_TIMEOUT);
this.release(void 0, 0);
} catch (err2) {
this.release(err2);
}
} else {
setTimeout(fsWrite, BUSY_WRITE_TIMEOUT);
}
} else {
this._writing = false;
this.emit("error", err);
}
return;
}
this.emit("write", n);
const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n);
this._len = releasedBufObj.len;
this._writingBuf = releasedBufObj.writingBuf;
if (this._writingBuf.length) {
if (!this.sync) {
fsWrite();
return;
}
try {
do {
const n2 = fsWriteSync();
const releasedBufObj2 = releaseWritingBuf(this._writingBuf, this._len, n2);
this._len = releasedBufObj2.len;
this._writingBuf = releasedBufObj2.writingBuf;
} while (this._writingBuf.length);
} catch (err2) {
this.release(err2);
return;
}
}
if (this._fsync) {
fs.fsyncSync(this.fd);
}
const len = this._len;
if (this._reopening) {
this._writing = false;
this._reopening = false;
this.reopen();
} else if (len > this.minLength) {
this._actualWrite();
}