lakutata
Version:
An IoC-based universal application framework.
7,130 lines • 179 kB
JavaScript
/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";
const e = require("./Package.internal.3.cjs");
const t = require("../src/lib/core/Component.cjs");
const r = require("../src/decorators/di/Lifetime.cjs");
const n = require("../src/decorators/di/Configurable.cjs");
const i = require("./Package.internal.7.cjs");
const s = require("node:os");
const o = require("node:events");
const c = require("node:diagnostics_channel");
const l = require("fs");
const a = require("events");
const f = require("util");
const u = require("path");
const h = require("assert");
const d = require("worker_threads");
const y = require("module");
const m = require("node:path");
const p = require("./Package.internal.2.cjs");
const g = require("url");
const b = require("buffer");
const v = require("./Package.internal.5.cjs");
const w = require("tty");
const S = require("node:stream");
const O = require("stream");
const E = require("string_decoder");
const _ = require("node:worker_threads");
const L = require("../src/lib/helpers/As.cjs");
const j = e => e && e.__esModule ? e : {
default: e
};
const x = j(s);
const k = j(o);
const A = j(c);
const T = j(l);
const C = j(a);
const B = j(f);
const D = j(u);
const $ = j(h);
const M = j(d);
const P = j(y);
const N = j(m);
const F = j(g);
const I = j(b);
const R = j(w);
const K = j(S);
const z = j(O);
const W = j(E);
const q = j(_);
var G = {
exports: {}
};
const V = e => e && typeof e.message === "string";
const U = e => {
if (!e) return;
const t = e.cause;
if (typeof t === "function") {
const t = e.cause();
return V(t) ? t : undefined;
} else {
return V(t) ? t : undefined;
}
};
const J = (e, t) => {
if (!V(e)) return "";
const r = e.stack || "";
if (t.has(e)) {
return r + "\ncauses have become circular...";
}
const n = U(e);
if (n) {
t.add(e);
return r + "\ncaused by: " + J(n, t);
} else {
return r;
}
};
const H = e => J(e, new Set);
const Y = (e, t, r) => {
if (!V(e)) return "";
const n = r ? "" : e.message || "";
if (t.has(e)) {
return n + ": ...";
}
const i = U(e);
if (i) {
t.add(e);
const r = typeof e.cause === "function";
return n + (r ? "" : ": ") + Y(i, t, r);
} else {
return n;
}
};
const X = e => Y(e, new Set);
var Z = {
isErrorLike: V,
getErrorCause: U,
stackWithCauses: H,
messageWithCauses: X
};
const Q = Symbol("circular-ref-tag");
const ee = Symbol("pino-raw-err-ref");
const te = Object.create({}, {
type: {
enumerable: true,
writable: true,
value: undefined
},
message: {
enumerable: true,
writable: true,
value: undefined
},
stack: {
enumerable: true,
writable: true,
value: undefined
},
aggregateErrors: {
enumerable: true,
writable: true,
value: undefined
},
raw: {
enumerable: false,
get: function() {
return this[ee];
},
set: function(e) {
this[ee] = e;
}
}
});
Object.defineProperty(te, ee, {
writable: true,
value: {}
});
var re = {
pinoErrProto: te,
pinoErrorSymbols: {
seen: Q,
rawSymbol: ee
}
};
var ne = ue;
const {messageWithCauses: ie, stackWithCauses: se, isErrorLike: oe} = Z;
const {pinoErrProto: ce, pinoErrorSymbols: le} = re;
const {seen: ae} = le;
const {toString: fe} = Object.prototype;
function ue(e) {
if (!oe(e)) {
return e;
}
e[ae] = undefined;
const t = Object.create(ce);
t.type = fe.call(e.constructor) === "[object Function]" ? e.constructor.name : e.name;
t.message = ie(e);
t.stack = se(e);
if (Array.isArray(e.errors)) {
t.aggregateErrors = e.errors.map(e => ue(e));
}
for (const r in e) {
if (t[r] === undefined) {
const n = e[r];
if (oe(n)) {
if (r !== "cause" && !Object.prototype.hasOwnProperty.call(n, ae)) {
t[r] = ue(n);
}
} else {
t[r] = n;
}
}
}
delete e[ae];
t.raw = e;
return t;
}
var he = be;
const {isErrorLike: de} = Z;
const {pinoErrProto: ye, pinoErrorSymbols: me} = re;
const {seen: pe} = me;
const {toString: ge} = Object.prototype;
function be(e) {
if (!de(e)) {
return e;
}
e[pe] = undefined;
const t = Object.create(ye);
t.type = ge.call(e.constructor) === "[object Function]" ? e.constructor.name : e.name;
t.message = e.message;
t.stack = e.stack;
if (Array.isArray(e.errors)) {
t.aggregateErrors = e.errors.map(e => be(e));
}
if (de(e.cause) && !Object.prototype.hasOwnProperty.call(e.cause, pe)) {
t.cause = be(e.cause);
}
for (const r in e) {
if (t[r] === undefined) {
const n = e[r];
if (de(n)) {
if (!Object.prototype.hasOwnProperty.call(n, pe)) {
t[r] = be(n);
}
} else {
t[r] = n;
}
}
}
delete e[pe];
t.raw = e;
return t;
}
var ve = {
mapHttpRequest: Ee,
reqSerializer: Oe
};
const we = Symbol("pino-raw-req-ref");
const Se = 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[we];
},
set: function(e) {
this[we] = e;
}
}
});
Object.defineProperty(Se, we, {
writable: true,
value: {}
});
function Oe(e) {
const t = e.info || e.socket;
const r = Object.create(Se);
r.id = typeof e.id === "function" ? e.id() : e.id || (e.info ? e.info.id : undefined);
r.method = e.method;
if (e.originalUrl) {
r.url = e.originalUrl;
} else {
const t = e.path;
r.url = typeof t === "string" ? t : e.url ? e.url.path || e.url : undefined;
}
if (e.query) {
r.query = e.query;
}
if (e.params) {
r.params = e.params;
}
r.headers = e.headers;
r.remoteAddress = t && t.remoteAddress;
r.remotePort = t && t.remotePort;
r.raw = e.raw || e;
return r;
}
function Ee(e) {
return {
req: Oe(e)
};
}
var _e = {
mapHttpResponse: ke,
resSerializer: xe
};
const Le = Symbol("pino-raw-res-ref");
const je = Object.create({}, {
statusCode: {
enumerable: true,
writable: true,
value: 0
},
headers: {
enumerable: true,
writable: true,
value: ""
},
raw: {
enumerable: false,
get: function() {
return this[Le];
},
set: function(e) {
this[Le] = e;
}
}
});
Object.defineProperty(je, Le, {
writable: true,
value: {}
});
function xe(e) {
const t = Object.create(je);
t.statusCode = e.headersSent ? e.statusCode : null;
t.headers = e.getHeaders ? e.getHeaders() : e._headers;
t.raw = e;
return t;
}
function ke(e) {
return {
res: xe(e)
};
}
const Ae = ne;
const Te = he;
const Ce = ve;
const Be = _e;
var De = {
err: Ae,
errWithCause: Te,
mapHttpRequest: Ce.mapHttpRequest,
mapHttpResponse: Be.mapHttpResponse,
req: Ce.reqSerializer,
res: Be.resSerializer,
wrapErrorSerializer: function e(t) {
if (t === Ae) return t;
return function e(r) {
return t(Ae(r));
};
},
wrapRequestSerializer: function e(t) {
if (t === Ce.reqSerializer) return t;
return function e(r) {
return t(Ce.reqSerializer(r));
};
},
wrapResponseSerializer: function e(t) {
if (t === Be.resSerializer) return t;
return function e(r) {
return t(Be.resSerializer(r));
};
}
};
function $e(e, t) {
return t;
}
var Me = function e() {
const t = Error.prepareStackTrace;
Error.prepareStackTrace = $e;
const r = (new Error).stack;
Error.prepareStackTrace = t;
if (!Array.isArray(r)) {
return undefined;
}
const n = r.slice(2);
const i = [];
for (const e of n) {
if (!e) {
continue;
}
i.push(e.getFileName());
}
return i;
};
function Pe(e) {
if (e === null || typeof e !== "object") {
return e;
}
if (e instanceof Date) {
return new Date(e.getTime());
}
if (e instanceof Array) {
const t = [];
for (let r = 0; r < e.length; r++) {
t[r] = Pe(e[r]);
}
return t;
}
if (typeof e === "object") {
const t = Object.create(Object.getPrototypeOf(e));
for (const r in e) {
if (Object.prototype.hasOwnProperty.call(e, r)) {
t[r] = Pe(e[r]);
}
}
return t;
}
return e;
}
function Ne(e) {
const t = [];
let r = "";
let n = false;
let i = false;
let s = "";
for (let o = 0; o < e.length; o++) {
const c = e[o];
if (!n && c === ".") {
if (r) {
t.push(r);
r = "";
}
} else if (c === "[") {
if (r) {
t.push(r);
r = "";
}
n = true;
} else if (c === "]" && n) {
t.push(r);
r = "";
n = false;
i = false;
} else if ((c === '"' || c === "'") && n) {
if (!i) {
i = true;
s = c;
} else if (c === s) {
i = false;
s = "";
} else {
r += c;
}
} else {
r += c;
}
}
if (r) {
t.push(r);
}
return t;
}
function Fe(e, t, r) {
let n = e;
for (let e = 0; e < t.length - 1; e++) {
const r = t[e];
if (typeof n !== "object" || n === null || !(r in n)) {
return false;
}
if (typeof n[r] !== "object" || n[r] === null) {
return false;
}
n = n[r];
}
const i = t[t.length - 1];
if (i === "*") {
if (Array.isArray(n)) {
for (let e = 0; e < n.length; e++) {
n[e] = r;
}
} else if (typeof n === "object" && n !== null) {
for (const e in n) {
if (Object.prototype.hasOwnProperty.call(n, e)) {
n[e] = r;
}
}
}
} else {
if (typeof n === "object" && n !== null && i in n && Object.prototype.hasOwnProperty.call(n, i)) {
n[i] = r;
}
}
return true;
}
function Ie(e, t) {
let r = e;
for (let e = 0; e < t.length - 1; e++) {
const n = t[e];
if (typeof r !== "object" || r === null || !(n in r)) {
return false;
}
if (typeof r[n] !== "object" || r[n] === null) {
return false;
}
r = r[n];
}
const n = t[t.length - 1];
if (n === "*") {
if (Array.isArray(r)) {
for (let e = 0; e < r.length; e++) {
r[e] = undefined;
}
} else if (typeof r === "object" && r !== null) {
for (const e in r) {
if (Object.prototype.hasOwnProperty.call(r, e)) {
delete r[e];
}
}
}
} else {
if (typeof r === "object" && r !== null && n in r && Object.prototype.hasOwnProperty.call(r, n)) {
delete r[n];
}
}
return true;
}
const Re = Symbol("PATH_NOT_FOUND");
function Ke(e, t) {
let r = e;
for (const e of t) {
if (r === null || r === undefined) {
return Re;
}
if (typeof r !== "object" || r === null) {
return Re;
}
if (!(e in r)) {
return Re;
}
r = r[e];
}
return r;
}
function ze(e, t) {
let r = e;
for (const e of t) {
if (r === null || r === undefined) {
return undefined;
}
if (typeof r !== "object" || r === null) {
return undefined;
}
r = r[e];
}
return r;
}
function We(e, t, r, n = false) {
for (const i of t) {
const t = Ne(i);
if (t.includes("*")) {
qe(e, t, r, i, n);
} else {
if (n) {
Ie(e, t);
} else {
const n = Ke(e, t);
if (n === Re) {
continue;
}
const i = typeof r === "function" ? r(n, t) : r;
Fe(e, t, i);
}
}
}
}
function qe(e, t, r, n, i = false) {
const s = t.indexOf("*");
if (s === t.length - 1) {
const n = t.slice(0, -1);
let s = e;
for (const e of n) {
if (s === null || s === undefined) return;
if (typeof s !== "object" || s === null) return;
s = s[e];
}
if (Array.isArray(s)) {
if (i) {
for (let e = 0; e < s.length; e++) {
s[e] = undefined;
}
} else {
for (let e = 0; e < s.length; e++) {
const t = [ ...n, e.toString() ];
const i = typeof r === "function" ? r(s[e], t) : r;
s[e] = i;
}
}
} else if (typeof s === "object" && s !== null) {
if (i) {
const e = [];
for (const t in s) {
if (Object.prototype.hasOwnProperty.call(s, t)) {
e.push(t);
}
}
for (const t of e) {
delete s[t];
}
} else {
for (const e in s) {
const t = [ ...n, e ];
const i = typeof r === "function" ? r(s[e], t) : r;
s[e] = i;
}
}
}
} else {
Ge(e, t, r, s, n, i);
}
}
function Ge(e, t, r, n, i, s = false) {
const o = t.slice(0, n);
const c = t.slice(n + 1);
const l = [];
function a(e, t) {
if (t === o.length) {
if (Array.isArray(e)) {
for (let r = 0; r < e.length; r++) {
l[t] = r.toString();
a(e[r], t + 1);
}
} else if (typeof e === "object" && e !== null) {
for (const r in e) {
l[t] = r;
a(e[r], t + 1);
}
}
} else if (t < o.length) {
const r = o[t];
if (e && typeof e === "object" && e !== null && r in e) {
l[t] = r;
a(e[r], t + 1);
}
} else {
if (c.includes("*")) {
const n = typeof r === "function" ? (e, n) => {
const i = [ ...l.slice(0, t), ...n ];
return r(e, i);
} : r;
qe(e, c, n, i, s);
} else {
if (s) {
Ie(e, c);
} else {
const n = typeof r === "function" ? r(ze(e, c), [ ...l.slice(0, t), ...c ]) : r;
Fe(e, c, n);
}
}
}
}
if (o.length === 0) {
a(e, 0);
} else {
let t = e;
for (let e = 0; e < o.length; e++) {
const r = o[e];
if (t === null || t === undefined) return;
if (typeof t !== "object" || t === null) return;
t = t[r];
l[e] = r;
}
if (t !== null && t !== undefined) {
a(t, o.length);
}
}
}
function Ve(e) {
if (e.length === 0) {
return null;
}
const t = new Map;
for (const r of e) {
const e = Ne(r);
let n = t;
for (let t = 0; t < e.length; t++) {
const r = e[t];
if (!n.has(r)) {
n.set(r, new Map);
}
n = n.get(r);
}
}
return t;
}
function Ue(e, t) {
if (!t) {
return e;
}
function r(e, t, n = 0) {
if (!t || t.size === 0) {
return e;
}
if (e === null || typeof e !== "object") {
return e;
}
if (e instanceof Date) {
return new Date(e.getTime());
}
if (Array.isArray(e)) {
const n = [];
for (let i = 0; i < e.length; i++) {
const s = i.toString();
if (t.has(s) || t.has("*")) {
n[i] = r(e[i], t.get(s) || t.get("*"));
} else {
n[i] = e[i];
}
}
return n;
}
const i = Object.create(Object.getPrototypeOf(e));
for (const n in e) {
if (Object.prototype.hasOwnProperty.call(e, n)) {
if (t.has(n) || t.has("*")) {
i[n] = r(e[n], t.get(n) || t.get("*"));
} else {
i[n] = e[n];
}
}
}
return i;
}
return r(e, t);
}
function Je(e) {
if (typeof e !== "string") {
throw new Error("Paths must be (non-empty) strings");
}
if (e === "") {
throw new Error("Invalid redaction path ()");
}
if (e.includes("..")) {
throw new Error(`Invalid redaction path (${e})`);
}
if (e.includes(",")) {
throw new Error(`Invalid redaction path (${e})`);
}
let t = 0;
let r = false;
let n = "";
for (let i = 0; i < e.length; i++) {
const s = e[i];
if ((s === '"' || s === "'") && t > 0) {
if (!r) {
r = true;
n = s;
} else if (s === n) {
r = false;
n = "";
}
} else if (s === "[" && !r) {
t++;
} else if (s === "]" && !r) {
t--;
if (t < 0) {
throw new Error(`Invalid redaction path (${e})`);
}
}
}
if (t !== 0) {
throw new Error(`Invalid redaction path (${e})`);
}
}
function He(e) {
if (!Array.isArray(e)) {
throw new TypeError("paths must be an array");
}
for (const t of e) {
Je(t);
}
}
function Ye(e = {}) {
const {paths: t = [], censor: r = "[REDACTED]", serialize: n = JSON.stringify, strict: i = true, remove: s = false} = e;
He(t);
const o = Ve(t);
return function e(c) {
if (i && (c === null || typeof c !== "object")) {
if (c === null || c === undefined) {
return n ? n(c) : c;
}
if (typeof c !== "object") {
return n ? n(c) : c;
}
}
const l = Ue(c, o);
const a = c;
let f = r;
if (typeof r === "function") {
f = r;
}
We(l, t, f, s);
if (n === false) {
l.restore = function() {
return Pe(a);
};
return l;
}
if (typeof n === "function") {
return n(l);
}
return JSON.stringify(l);
};
}
var Xe = Ye;
const Ze = Symbol("pino.setLevel");
const Qe = Symbol("pino.getLevel");
const et = Symbol("pino.levelVal");
const tt = Symbol("pino.levelComp");
const rt = Symbol("pino.useLevelLabels");
const nt = Symbol("pino.useOnlyCustomLevels");
const it = Symbol("pino.mixin");
const st = Symbol("pino.lsCache");
const ot = Symbol("pino.chindings");
const ct = Symbol("pino.asJson");
const lt = Symbol("pino.write");
const at = Symbol("pino.redactFmt");
const ft = Symbol("pino.time");
const ut = Symbol("pino.timeSliceIndex");
const ht = Symbol("pino.stream");
const dt = Symbol("pino.stringify");
const yt = Symbol("pino.stringifySafe");
const mt = Symbol("pino.stringifiers");
const pt = Symbol("pino.end");
const gt = Symbol("pino.formatOpts");
const bt = Symbol("pino.messageKey");
const vt = Symbol("pino.errorKey");
const wt = Symbol("pino.nestedKey");
const St = Symbol("pino.nestedKeyStr");
const Ot = Symbol("pino.mixinMergeStrategy");
const Et = Symbol("pino.msgPrefix");
const _t = Symbol("pino.wildcardFirst");
const Lt = Symbol.for("pino.serializers");
const jt = Symbol.for("pino.formatters");
const xt = Symbol.for("pino.hooks");
const kt = Symbol.for("pino.metadata");
var At = {
setLevelSym: Ze,
getLevelSym: Qe,
levelValSym: et,
levelCompSym: tt,
useLevelLabelsSym: rt,
mixinSym: it,
lsCacheSym: st,
chindingsSym: ot,
asJsonSym: ct,
writeSym: lt,
serializersSym: Lt,
redactFmtSym: at,
timeSym: ft,
timeSliceIndexSym: ut,
streamSym: ht,
stringifySym: dt,
stringifySafeSym: yt,
stringifiersSym: mt,
endSym: pt,
formatOptsSym: gt,
messageKeySym: bt,
errorKeySym: vt,
nestedKeySym: wt,
wildcardFirstSym: _t,
needsMetadataGsym: kt,
useOnlyCustomLevelsSym: nt,
formattersSym: jt,
hooksSym: xt,
nestedKeyStrSym: St,
mixinMergeStrategySym: Ot,
msgPrefixSym: Et
};
const Tt = Xe;
const {redactFmtSym: Ct, wildcardFirstSym: Bt} = At;
const Dt = /[^.[\]]+|\[([^[\]]*?)\]/g;
const $t = "[Redacted]";
const Mt = false;
function Pt(e, t) {
const {paths: r, censor: n, remove: i} = Nt(e);
const s = r.reduce((e, t) => {
Dt.lastIndex = 0;
const r = Dt.exec(t);
const n = Dt.exec(t);
let i = r[1] !== undefined ? r[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, "$1") : r[0];
if (i === "*") {
i = Bt;
}
if (n === null) {
e[i] = null;
return e;
}
if (e[i] === null) {
return e;
}
const {index: s} = n;
const o = `${t.substr(s, t.length - 1)}`;
e[i] = e[i] || [];
if (i !== Bt && e[i].length === 0) {
e[i].push(...e[Bt] || []);
}
if (i === Bt) {
Object.keys(e).forEach(function(t) {
if (e[t]) {
e[t].push(o);
}
});
}
e[i].push(o);
return e;
}, {});
const o = {
[Ct]: Tt({
paths: r,
censor: n,
serialize: t,
strict: Mt,
remove: i
})
};
const c = (...e) => typeof n === "function" ? t(n(...e)) : t(n);
return [ ...Object.keys(s), ...Object.getOwnPropertySymbols(s) ].reduce((e, r) => {
if (s[r] === null) {
e[r] = e => c(e, [ r ]);
} else {
const o = typeof n === "function" ? (e, t) => n(e, [ r, ...t ]) : n;
e[r] = Tt({
paths: s[r],
censor: o,
serialize: t,
strict: Mt,
remove: i
});
}
return e;
}, o);
}
function Nt(e) {
if (Array.isArray(e)) {
e = {
paths: e,
censor: $t
};
return e;
}
let {paths: t, censor: r = $t, remove: n} = e;
if (Array.isArray(t) === false) {
throw Error("pino – redact must contain an array of strings");
}
if (n === true) r = undefined;
return {
paths: t,
censor: r,
remove: n
};
}
var Ft = Pt;
const It = () => "";
const Rt = () => `,"time":${Date.now()}`;
const Kt = () => `,"time":${Math.round(Date.now() / 1e3)}`;
const zt = () => `,"time":"${new Date(Date.now()).toISOString()}"`;
const Wt = 1000000n;
const qt = 1000000000n;
const Gt = BigInt(Date.now()) * Wt;
const Vt = process.hrtime.bigint();
const Ut = () => {
const e = process.hrtime.bigint() - Vt;
const t = Gt + e;
const r = t / qt;
const n = t % qt;
const i = Number(r * 1000n + n / 1000000n);
const s = new Date(i);
const o = s.getUTCFullYear();
const c = (s.getUTCMonth() + 1).toString().padStart(2, "0");
const l = s.getUTCDate().toString().padStart(2, "0");
const a = s.getUTCHours().toString().padStart(2, "0");
const f = s.getUTCMinutes().toString().padStart(2, "0");
const u = s.getUTCSeconds().toString().padStart(2, "0");
return `,"time":"${o}-${c}-${l}T${a}:${f}:${u}.${n.toString().padStart(9, "0")}Z"`;
};
var Jt = {
nullTime: It,
epochTime: Rt,
unixTime: Kt,
isoTime: zt,
isoTimeNano: Ut
};
function Ht(e) {
try {
return JSON.stringify(e);
} catch (e) {
return '"[Circular]"';
}
}
var Yt = Xt;
function Xt(e, t, r) {
var n = r && r.stringify || Ht;
var i = 1;
if (typeof e === "object" && e !== null) {
var s = t.length + i;
if (s === 1) return e;
var o = new Array(s);
o[0] = n(e);
for (var c = 1; c < s; c++) {
o[c] = n(t[c]);
}
return o.join(" ");
}
if (typeof e !== "string") {
return e;
}
var l = t.length;
if (l === 0) return e;
var a = "";
var f = 1 - i;
var u = -1;
var h = e && e.length || 0;
for (var d = 0; d < h; ) {
if (e.charCodeAt(d) === 37 && d + 1 < h) {
u = u > -1 ? u : 0;
switch (e.charCodeAt(d + 1)) {
case 100:
case 102:
if (f >= l) break;
if (t[f] == null) break;
if (u < d) a += e.slice(u, d);
a += Number(t[f]);
u = d + 2;
d++;
break;
case 105:
if (f >= l) break;
if (t[f] == null) break;
if (u < d) a += e.slice(u, d);
a += Math.floor(Number(t[f]));
u = d + 2;
d++;
break;
case 79:
case 111:
case 106:
if (f >= l) break;
if (t[f] === undefined) break;
if (u < d) a += e.slice(u, d);
var y = typeof t[f];
if (y === "string") {
a += "'" + t[f] + "'";
u = d + 2;
d++;
break;
}
if (y === "function") {
a += t[f].name || "<anonymous>";
u = d + 2;
d++;
break;
}
a += n(t[f]);
u = d + 2;
d++;
break;
case 115:
if (f >= l) break;
if (u < d) a += e.slice(u, d);
a += String(t[f]);
u = d + 2;
d++;
break;
case 37:
if (u < d) a += e.slice(u, d);
a += "%";
u = d + 2;
d++;
f--;
break;
}
++f;
}
++d;
}
if (u === -1) return e; else if (u < h) {
a += e.slice(u);
}
return a;
}
var Zt = {
exports: {}
};
Zt.exports;
var Qt;
function er() {
if (Qt) return Zt.exports;
Qt = 1;
if (typeof SharedArrayBuffer !== "undefined" && typeof Atomics !== "undefined") {
const e = new Int32Array(new SharedArrayBuffer(4));
function t(t) {
const r = t > 0 && t < Infinity;
if (r === false) {
if (typeof t !== "number" && typeof t !== "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(e, 0, 0, Number(t));
}
Zt.exports = t;
} else {
function r(e) {
const t = e > 0 && e < Infinity;
if (t === false) {
if (typeof e !== "number" && typeof e !== "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");
}
}
Zt.exports = r;
}
return Zt.exports;
}
const tr = T.default;
const rr = C.default;
const nr = B.default.inherits;
const ir = D.default;
const sr = er();
const or = $.default;
const cr = 100;
const lr = Buffer.allocUnsafe(0);
const ar = 16 * 1024;
const fr = "buffer";
const ur = "utf8";
const [hr, dr] = (process.versions.node || "0.0").split(".").map(Number);
const yr = hr >= 22 && dr >= 7;
function mr(e, t) {
t._opening = true;
t._writing = true;
t._asyncDrainScheduled = false;
function r(r, n) {
if (r) {
t._reopening = false;
t._writing = false;
t._opening = false;
if (t.sync) {
process.nextTick(() => {
if (t.listenerCount("error") > 0) {
t.emit("error", r);
}
});
} else {
t.emit("error", r);
}
return;
}
const i = t._reopening;
t.fd = n;
t.file = e;
t._reopening = false;
t._opening = false;
t._writing = false;
if (t.sync) {
process.nextTick(() => t.emit("ready"));
} else {
t.emit("ready");
}
if (t.destroyed) {
return;
}
if (!t._writing && t._len > t.minLength || t._flushPending) {
t._actualWrite();
} else if (i) {
process.nextTick(() => t.emit("drain"));
}
}
const n = t.append ? "a" : "w";
const i = t.mode;
if (t.sync) {
try {
if (t.mkdir) tr.mkdirSync(ir.dirname(e), {
recursive: true
});
const s = tr.openSync(e, n, i);
r(null, s);
} catch (e) {
r(e);
throw e;
}
} else if (t.mkdir) {
tr.mkdir(ir.dirname(e), {
recursive: true
}, t => {
if (t) return r(t);
tr.open(e, n, i, r);
});
} else {
tr.open(e, n, i, r);
}
}
function pr(e) {
if (!(this instanceof pr)) {
return new pr(e);
}
let {fd: t, dest: r, minLength: n, maxLength: i, maxWrite: s, periodicFlush: o, sync: c, append: l = true, mkdir: a, retryEAGAIN: f, fsync: u, contentMode: h, mode: d} = e || {};
t = t || r;
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(n || 0, 16387);
this.file = null;
this.destroyed = false;
this.minLength = n || 0;
this.maxLength = i || 0;
this.maxWrite = s || ar;
this._periodicFlush = o || 0;
this._periodicFlushTimer = undefined;
this.sync = c || false;
this.writable = true;
this._fsync = u || false;
this.append = l || false;
this.mode = d;
this.retryEAGAIN = f || (() => true);
this.mkdir = a || false;
let y;
let m;
if (h === fr) {
this._writingBuf = lr;
this.write = Sr;
this.flush = _r;
this.flushSync = jr;
this._actualWrite = kr;
y = () => tr.writeSync(this.fd, this._writingBuf);
m = () => tr.write(this.fd, this._writingBuf, this.release);
} else if (h === undefined || h === ur) {
this._writingBuf = "";
this.write = wr;
this.flush = Er;
this.flushSync = Lr;
this._actualWrite = xr;
y = () => tr.writeSync(this.fd, this._writingBuf, "utf8");
m = () => tr.write(this.fd, this._writingBuf, "utf8", this.release);
} else {
throw new Error(`SonicBoom supports "${ur}" and "${fr}", but passed ${h}`);
}
if (typeof t === "number") {
this.fd = t;
process.nextTick(() => this.emit("ready"));
} else if (typeof t === "string") {
mr(t, 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 = (e, t) => {
if (e) {
if ((e.code === "EAGAIN" || e.code === "EBUSY") && this.retryEAGAIN(e, this._writingBuf.length, this._len - this._writingBuf.length)) {
if (this.sync) {
try {
sr(cr);
this.release(undefined, 0);
} catch (e) {
this.release(e);
}
} else {
setTimeout(m, cr);
}
} else {
this._writing = false;
this.emit("error", e);
}
return;
}
this.emit("write", t);
const r = gr(this._writingBuf, this._len, t);
this._len = r.len;
this._writingBuf = r.writingBuf;
if (this._writingBuf.length) {
if (!this.sync) {
m();
return;
}
try {
do {
const e = y();
const t = gr(this._writingBuf, this._len, e);
this._len = t.len;
this._writingBuf = t.writingBuf;
} while (this._writingBuf.length);
} catch (e) {
this.release(e);
return;
}
}
if (this._fsync) {
tr.fsyncSync(this.fd);
}
const n = this._len;
if (this._reopening) {
this._writing = false;
this._reopening = false;
this.reopen();
} else if (n > this.minLength) {
this._actualWrite();
} else if (this._ending) {
if (n > 0) {
this._actualWrite();
} else {
this._writing = false;
Ar(this);
}
} else {
this._writing = false;
if (this.sync) {
if (!this._asyncDrainScheduled) {
this._asyncDrainScheduled = true;
process.nextTick(br, this);
}
} else {
this.emit("drain");
}
}
};
this.on("newListener", function(e) {
if (e === "drain") {
this._asyncDrainScheduled = false;
}
});
if (this._periodicFlush !== 0) {
this._periodicFlushTimer = setInterval(() => this.flush(null), this._periodicFlush);
this._periodicFlushTimer.unref();
}
}
function gr(e, t, r) {
if (typeof e === "string" && Buffer.byteLength(e) !== r) {
r = Buffer.from(e).subarray(0, r).toString().length;
}
t = Math.max(t - r, 0);
e = e.slice(r);
return {
writingBuf: e,
len: t
};
}
function br(e) {
const t = e.listenerCount("drain") > 0;
if (!t) return;
e._asyncDrainScheduled = false;
e.emit("drain");
}
nr(pr, rr);
function vr(e, t) {
if (e.length === 0) {
return lr;
}
if (e.length === 1) {
return e[0];
}
return Buffer.concat(e, t);
}
function wr(e) {
if (this.destroyed) {
throw new Error("SonicBoom destroyed");
}
const t = this._len + e.length;
const r = this._bufs;
if (this.maxLength && t > this.maxLength) {
this.emit("drop", e);
return this._len < this._hwm;
}
if (r.length === 0 || r[r.length - 1].length + e.length > this.maxWrite) {
r.push("" + e);
} else {
r[r.length - 1] += e;
}
this._len = t;
if (!this._writing && this._len >= this.minLength) {
this._actualWrite();
}
return this._len < this._hwm;
}
function Sr(e) {
if (this.destroyed) {
throw new Error("SonicBoom destroyed");
}
const t = this._len + e.length;
const r = this._bufs;
const n = this._lens;
if (this.maxLength && t > this.maxLength) {
this.emit("drop", e);
return this._len < this._hwm;
}
if (r.length === 0 || n[n.length - 1] + e.length > this.maxWrite) {
r.push([ e ]);
n.push(e.length);
} else {
r[r.length - 1].push(e);
n[n.length - 1] += e.length;
}
this._len = t;
if (!this._writing && this._len >= this.minLength) {
this._actualWrite();
}
return this._len < this._hwm;
}
function Or(e) {
this._flushPending = true;
const t = () => {
if (!this._fsync) {
try {
tr.fsync(this.fd, t => {
this._flushPending = false;
e(t);
});
} catch (t) {
e(t);
}
} else {
this._flushPending = false;
e();
}
this.off("error", r);
};
const r = r => {
this._flushPending = false;
e(r);
this.off("drain", t);
};
this.once("drain", t);
this.once("error", r);
}
function Er(e) {
if (e != null && typeof e !== "function") {
throw new Error("flush cb must be a function");
}
if (this.destroyed) {
const t = new Error("SonicBoom destroyed");
if (e) {
e(t);
return;
}
throw t;
}
if (this.minLength <= 0) {
e?.();
return;
}
if (e) {
Or.call(this, e);
}
if (this._writing) {
return;
}
if (this._bufs.length === 0) {
this._bufs.push("");
}
this._actualWrite();
}
function _r(e) {
if (e != null && typeof e !== "function") {
throw new Error("flush cb must be a function");
}
if (this.destroyed) {
const t = new Error("SonicBoom destroyed");
if (e) {
e(t);
return;
}
throw t;
}
if (this.minLength <= 0) {
e?.();
return;
}
if (e) {
Or.call(this, e);
}
if (this._writing) {
return;
}
if (this._bufs.length === 0) {
this._bufs.push([]);
this._lens.push(0);
}
this._actualWrite();
}
pr.prototype.reopen = function(e) {
if (this.destroyed) {
throw new Error("SonicBoom destroyed");
}
if (this._opening) {
this.once("ready", () => {
this.reopen(e);
});
return;
}
if (this._ending) {
return;
}
if (!this.file) {
throw new Error("Unable to reopen a file descriptor, you must pass a file to SonicBoom");
}
if (e) {
this.file = e;
}
this._reopening = true;
if (this._writing) {
return;
}
const t = this.fd;
this.once("ready", () => {
if (t !== this.fd) {
tr.close(t, e => {
if (e) {
return this.emit("error", e);
}
});
}
});
mr(this.file, this);
};
pr.prototype.end = function() {
if (this.destroyed) {
throw new Error("SonicBoom destroyed");
}
if (this._opening) {
this.once("ready", () => {
this.end();
});
return;
}
if (this._ending) {
return;
}
this._ending = true;
if (this._writing) {
return;
}
if (this._len > 0 && this.fd >= 0) {
this._actualWrite();
} else {
Ar(this);
}
};
function Lr() {
if (this.destroyed) {
throw new Error("SonicBoom destroyed");
}
if (this.fd < 0) {
throw new Error("sonic boom is not ready yet");
}
if (!this._writing && this._writingBuf.length > 0) {
this._bufs.unshift(this._writingBuf);
this._writingBuf = "";
}
let e = "";
while (this._bufs.length || e) {
if (e.length <= 0) {
e = this._bufs[0];
}
try {
const t = tr.writeSync(this.fd, e, "utf8");
const r = gr(e, this._len, t);
e = r.writingBuf;
this._len = r.len;
if (e.length <= 0) {
this._bufs.shift();
}
} catch (t) {
const r = t.code === "EAGAIN" || t.code === "EBUSY";
if (r && !this.retryEAGAIN(t, e.length, this._len - e.length)) {
throw t;
}
sr(cr);
}
}
try {
tr.fsyncSync(this.fd);
} catch {}
}
function jr() {
if (this.destroyed) {
throw new Error("SonicBoom destroyed");
}
if (this.fd < 0) {
throw new Error("sonic boom is not ready yet");
}
if (!this._writing && this._writingBuf.length > 0) {
this._bufs.unshift([ this._writingBuf ]);
this._writingBuf = lr;
}
let e = lr;
while (this._bufs.length || e.length) {
if (e.length <= 0) {
e = vr(this._bufs[0], this._lens[0]);
}
try {
const t = tr.writeSync(this.fd, e);
e = e.subarray(t);
this._len = Math.max(this._len - t, 0);
if (e.length <= 0) {
this._bufs.shift();
this._lens.shift();
}
} catch (t) {
const r = t.code === "EAGAIN" || t.code === "EBUSY";
if (r && !this.retryEAGAIN(t, e.length, this._len - e.length)) {
throw t;
}
sr(cr);
}
}
}
pr.prototype.destroy = function() {
if (this.destroyed) {
return;
}
Ar(this);
};
function xr() {
const e = this.release;
this._writing = true;
this._writingBuf = this._writingBuf || this._bufs.shift() || "";
if (this.sync) {
try {
const t = tr.writeSync(this.fd, this._writingBuf, "utf8");
e(null, t);
} catch (t) {
e(t);
}
} else {
tr.write(this.fd, this._writingBuf, "utf8", e);
}
}
function kr() {
const e = this.release;
this._writing = true;
this._writingBuf = this._writingBuf.length ? this._writingBuf : vr(this._bufs.shift(), this._lens.shift());
if (this.sync) {
try {
const t = tr.writeSync(this.fd, this._writingBuf);
e(null, t);
} catch (t) {
e(t);
}
} else {
if (yr) {
this._writingBuf = Buffer.from(this._writingBuf);
}
tr.write(this.fd, this._writingBuf, e);
}
}
function Ar(e) {
if (e.fd === -1) {
e.once("ready", Ar.bind(null, e));
return;
}
if (e._periodicFlushTimer !== undefined) {
clearInterval(e._periodicFlushTimer);
}
e.destroyed = true;
e._bufs = [];
e._lens = [];
or(typeof e.fd === "number", `sonic.fd must be a number, got ${typeof e.fd}`);
try {
tr.fsync(e.fd, t);
} catch {}
function t() {
if (e.fd !== 1 && e.fd !== 2) {
tr.close(e.fd, r);
} else {
r();
}
}
function r(t) {
if (t) {
e.emit("error", t);
return;
}
if (e._ending && !e._writing) {
e.emit("finish");
}
e.emit("close");
}
}
pr.SonicBoom = pr;
pr.default = pr;
var Tr = pr;
const Cr = {
exit: [],
beforeExit: []
};
const Br = {
exit: Nr,
beforeExit: Fr
};
let Dr;
function $r() {
if (Dr === undefined) {
Dr = new FinalizationRegistry(Rr);
}
}
function Mr(e) {
if (Cr[e].length > 0) {
return;
}
process.on(e, Br[e]);
}
function Pr(e) {
if (Cr[e].length > 0) {
return;
}
process.removeListener(e, Br[e]);
if (Cr.exit.length === 0 && Cr.beforeExit.length === 0) {
Dr = undefined;
}
}
function Nr() {
Ir("exit");
}
function Fr() {
Ir("beforeExit");
}
function Ir(e) {
for (const t of Cr[e]) {
const r = t.deref();
const n = t.fn;
if (r !== undefined) {
n(r, e);
}
}
Cr[e] = [];
}
function Rr(e) {
for (const t of [ "exit", "beforeExit" ]) {
const r = Cr[t].indexOf(e);
Cr[t].splice(r, r + 1);
Pr(t);
}
}
function Kr(e, t, r) {
if (t === undefined) {
throw new Error("the object can't be undefined");
}
Mr(e);
const n = new WeakRef(t);
n.fn = r;
$r();
Dr.register(t, n);
Cr[e].push(n);
}
function zr(e, t) {
Kr("exit", e, t);
}
function Wr(e, t) {
Kr("beforeExit", e, t);
}
function qr(e) {
if (Dr === undefined) {
return;
}
Dr.unregister(e);
for (const t of [ "exit", "beforeExit" ]) {
Cr[t] = Cr[t].filter(t => {
const r = t.deref();
return r && r !== e;
});
Pr(t);
}
}
var Gr = {
register: zr,
registerBeforeExit: Wr,
unregister: qr
};
var Vr = "3.1.0";
const Ur = {
version: Vr
};
var Jr;
var Hr;
function Yr() {
if (Hr) return Jr;
Hr = 1;
const e = 1e3;
function t(t, r, n, i, s) {
const o = Date.now() + i;
let c = Atomics.load(t, r);
if (c === n) {
s(null, "ok");
return;
}
let l = c;
const a = i => {
if (Date.now() > o) {
s(null, "timed-out");
} else {
setTimeout(() => {
l = c;
c = Atomics.load(t, r);
if (c === l) {
a(i >= e ? e : i * 2);
} else {
if (c === n) s(null, "ok"); else s(null, "not-equal");
}
}, i);
}
};
a(1);
}
function r(t, r, n, i, s) {
const o = Date.now() + i;
let c = Atomics.load(t, r);
if (c !== n) {
s(null, "ok");
return;
}
const l = i => {
if (Date.now() > o) {
s(null, "timed-out");
} else {
setTimeout(() => {
c = Atomics.load(t, r);
if (c !== n) {
s(null, "ok");
} else {
l(i >= e ? e : i * 2);
}
}, i);
}
};
l(1);
}
Jr = {
wait: t,
waitDiff: r
};
return Jr;
}
var Xr;
var Zr;
function Qr() {
if (Zr) return Xr;
Zr = 1;
const e = 4;
const t = 8;
Xr = {
WRITE_INDEX: e,
READ_INDEX: t
};
return Xr;
}
var en;
var tn;
function rn() {
if (tn) return en;
tn = 1;
const {version: e} = Ur;
const {EventEmitter: t} = C.default;
const {Worker: r} = M.default;
const {join: n} = D.default;
const {pathToFileURL: i} = F.default;
const {wait: s} = Yr();
const {WRITE_INDEX: o, READ_INDEX: c} = Qr();
const l = I.default;
const a = $.default;
const f = Symbol("kImpl");
const u = l.constants.MAX_STRING_LENGTH;
class FakeWeakRef {
constructor(e) {
this._value = e;
}
deref() {
return this._value;
}
}
class FakeFinalizationRegistry {
register() {}
unregister() {}
}
const h = process.env.NODE_V8_COVERAGE ? FakeFinalizationRegistry : p.commonjsGlobal.FinalizationRegistry || FakeFinalizationRegistry;
const d = process.env.NODE_V8_COVERAGE ? FakeWeakRef : p.commonjsGlobal.WeakRef || FakeWeakRef;
const y = new h(e => {
if (e.exited) {
return;
}
e.terminate();
});
function m(t, s) {
const {filename: o, workerData: c} = s;
const l = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
const a = l["thread-stream-worker"] || n(__dirname, "lib", "worker.js");
const u = new r(a, {
...s.workerOpts,
trackUnmanagedFds: false,
workerData: {
filename: o.indexOf("file://") === 0 ? o : i(o).href,
dataBuf: t[f].dataBuf,
stateBuf: t[f].stateBuf,
workerData: {
$context: {
threadStreamVersion: e
},
...c
}
}
});
u.stream = new FakeWeakRef(t);
u.on("message", v);
u.on("exit", w);
y.register(t, u);
return u;
}
function g(e) {
a(!e[f].sync);
if (e[f].needDrain) {
e[f].needDrain = false;
e.emit("drain");
}
}
function b(e) {
const t = Atomics.load(e[f].state, o);
let r = e[f].data.length - t;
if (r > 0) {
if (e[f].buf.length === 0) {
e[f].flushing = false;
if (e[f].ending) {
_(e);
} else if (e[f].needDrain) {
process.nextTick(g, e);
}
return;
}
let t = e[f].buf.slice(0, r);
let n = Buffer.byteLength(t);
if (n <= r) {
e[f].buf = e[f].buf.slice(r);
E(e, t, b.bind(null, e));
} else {
e.flush(() => {
if (e.destroyed) {
return;
}
Atomics.store(e[f].state, c, 0);
Atomics.store(e[f].state, o, 0);
while (n > e[f].data.length) {
r = r / 2;
t = e[f].buf.slice(0, r);
n = Buffer.byteLength(t);
}
e[f].buf = e[f].buf.slice(r);
E(e, t, b.bind(null, e));
});
}
} else if (r === 0) {
if (t === 0 && e[f].buf.length === 0) {
return;
}
e.flush(() => {
Atomics.store(e[f].state, c, 0);
Atomics.store(e[f].state, o, 0);
b(e);
});
} else {
O(e, new Error("overwritten"));
}
}
function v(e) {
const t = this.stream.deref();
if (t === undefined) {
this.exited = true;
this.terminate();
return;
}
switch (e.code) {
case "READY":
this.stream = new d(t);
t.flush(() => {
t[f].ready = true;
t.emit("ready");
});
break;
case "ERROR":
O(t, e.err);
break;
case "EVENT":
if (Array.isArray(e.args)) {
t.emit(e.name, ...e.args);
} else {
t.emit(e.name, e.args);
}
break;
case "WARNING":
process.emitWarning(e.err);
break;
default:
O(t, new Error("this should not happen: " + e.code));
}
}
function w(e) {
const t = this.stream.deref();
if (t === undefined) {
return;
}
y.unregister(t);
t.worker.exited = true;
t.worker.off("exit", w);
O(t, e !== 0 ? new Error("the worker thread exited") : null);
}
class ThreadStream extends t {
constructor(e = {}) {
super();
if (e.bufferSize < 4) {
throw new Error("bufferSize must at least fit a 4-byte utf-8 char");
}
this[f] = {};
this[f].stateBuf = new SharedArrayBuffer(128);
this[f].state = new Int32Array(this[f].stateBuf);
this[f].dataBuf = new SharedArrayBuffer(e.bufferSize || 4 * 1024 * 1024);
this[f].data = Buffer.from(this[f].dataBuf);
this[f].sync = e.sync || false;
this[f].ending = false;
this[f].ended = false;
this[f].needDrain = false;
this[f].destroyed = false;
this[f].flushing = false;
this[f].ready = false;
this[f].finished = false;
this[f].errored = null;
this[f].closed = false;
this[f].buf = "";
this.worker = m(this, e);
this.on("message", (e, t) => {
this.worker.postMessage(e, t);
});
}
write(e) {
if (this[f].destroyed) {
S(this, new Error("the worker has exited"));
return false;
}
if (this[f].ending) {
S(this, new Error("the worker is ending"));
return false;
}
if (this[f].flushing && this[f].buf.length + e.length >= u) {
try {
L(this);
this[f].flushing = true;
} catch (e) {
O(this, e);
return false;
}
}
this[f].buf += e;
if (this[f].sync) {
try {
L(this);
return true;
} catch (e) {
O(this, e);
return false;
}
}
if (!this[f].flushing) {
this[f].flushing = true;
setImmediate(b, this);
}
this[f].needDrain = this[f].data.length - this[f].buf.length - Atomics.load(this[f].state, o) <= 0;
return !this[f].needDrain;
}
end() {
if (this[f].destroyed) {
return;
}
this[f].ending = true;
_(this);
}
flush(e) {
if (this[f].destroyed) {
if (typeof e === "function") {
process.nextTick(e, new Error("the worker has exited"));
}
return;
}
const t = Atomics.load(this[f].state, o);
s(this[f].state, c, t, Infinity, (t, r) => {
if (t) {
O(this, t);
process.nextTick(e, t);
return;
}
if (r === "not-equal") {
this.flush(e);
return;
}
process.nextTick(e);
});
}
flushSync() {
if (this[f].destroyed) {
return;
}
L(this);
j(this);
}
unref() {
this.worker.unref();
}
ref() {
this.worker.ref();
}
get ready() {
return this[f].ready;
}
get destroyed() {
return this[f].destroyed;
}
get closed() {
return this[f].closed;
}
get writable() {
return !this[f].destroyed && !this[f].ending;
}
get writableEnded() {
return this[f].ending;
}
get writableFinished() {
return this[f].finished;
}
get writableNeedDrain() {
return this[f].needDrain;
}
get writableObjectMode() {
return false;
}
get writableErrored() {
return this[f].errored;
}
}
function S(e, t) {
setImmediate(() => {
e.emit("error", t);
});
}
function O(e, t) {
if (e[f].destroyed) {
return;
}
e[f].destroyed = true;
if (t) {
e[f].errored = t;
S(e, t);
}
if (!e.worker.exited) {
e.worker.terminate().catch(() => {}).then(() => {
e[f].closed = true;
e.emit("close");
});
} else {
setImmediate(() => {
e[f].closed = true;
e.emit("close");
});
}
}
function E(e, t, r) {
const n = Atomics.load(e[f].state, o);
const i = Buffer.byteLength(t);
e[f].data.write(t, n);
Atomics.store(e[f].state, o, n + i);
Atomics.notify(e[f].state, o);
r();
return true;
}
function _(e) {
if (e[f].ended || !e[f].ending || e[f].flushing) {
return;
}
e[f].ended = true;
try {
e.flushSync();
let t = Atomics.load(e[f].state, c);
Atomics.store(e[f].state, o, -1);
Atomics.notify(e[f].state, o);
let r = 0;
while (t !== -1) {
Atomics.wait(e[f].state, c, t, 1e3);
t = Atomics.load(e[f].state, c);
if (t === -2) {
O(e, new Error("end() failed"));
return;
}
if (++r === 10) {
O(e, new Error("end() took too long (10s)"));
return;
}
}
process.nextTick(() => {
e[f].finished = true;
e.emit("finish");
});
} catch (t) {
O(e, t);
}
}
function L(e) {
const t = () => {
if (e[f].ending) {
_(e);
} else if (e[f].needDrain) {
process.nextTick(g, e);
}
};
e[f].flushing = false;
while (e[f].buf.length !== 0) {
const r = Atomics.load(e[f].state, o);
let n = e[f].data.length - r;
if (n === 0) {
j(e);
Atomics.store(e[f].state, c, 0);
Atomics.store(e[f].state, o, 0);
continue;
} else if (n < 0) {
throw new Error("overwritten");
}
let i = e[f].buf.slice(0, n);
let s = Buffer.byteLength(i);
if (s <= n) {
e[f].buf = e[f].buf.slice(n);
E(e, i, t);
} else {
j(e);
Atomics.store(e[f].state, c, 0);
Atomics.store(e[f].state, o, 0);
while (s > e[f].buf.length) {
n = n / 2;
i = e[f].buf.slice(0, n);
s = Buffer.byteLength(i);
}
e[f].buf = e[f].buf.slice(n);
E(e, i, t);
}
}
}
function j(e) {
if (e[f].flushing) {
throw new Error("unable to flush while flushing");
}
const t = Atomics.load(e[f].state, o);
let r = 0;
while (true) {
const n = Atomics.load(e[f].state, c);
if (n === -2) {
throw Error("_flushSync failed");
}
if (n !== t) {
Atomics.wait(e[f].state, c, n, 1e3);
} else {
break;
}
if (++r === 10) {
throw new Error("_flushSync took too long (10s)");
}
}
}
en = ThreadStream;
return en;
}
var nn;
var sn;
function on() {
if (sn) return nn;
sn = 1;
const {createRequire: e} = P.default;
const t = Me;
const {join: r, isAbsolute: n, sep: i} = N.default;
const s = er();
const o = Gr;
const c = rn();
function l(e) {
o.register(e, f);
o.registerBeforeExit(e, u);
e.on("close", function() {
o.unregister(e);
});
}
function a(e, t, r, n) {
const i = new c({
filename: e,
workerData: t,
workerOpts: r,
sync: n
});
i.on("ready", o);
i.on("close", function() {
process.removeListener("exit", a);
});
process.on("exit", a);
function o() {
process.removeListener("exit", a);
i.unref();
if (r.autoEnd !== false) {
l(i);
}
}
function a() {
if (i.closed) {
return;
}
i.flushSync();
s(100);
i.end();
}
return i;
}
function f(e) {
e.ref();
e.flushSync();
e.end();
e.once("close", function() {
e.unref();
});
}
function u(e) {
e.flushSync();
}
function h(s) {
const {pipeline: o, targets: c, levels: l, dedupe: f, worker: u = {}, caller: h = t(), sync: d = false} = s;
const y = {
...s.options
};
const m = typeof h === "string" ? [ h ] : h;
const p = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
let g = s.target;
if (g && c) {
throw new Error("only one of target or targets can be specified");
}
if (c) {
g = p["pino-worker"] || r(__dirname, "worker.js");
y.targets = c.filter(e => e.target).map(e => ({
...e,
target: b(e.target)
}));
y.pipelines = c.filter(e => e.pipeline).map(e => e.pipeline.map(t => ({
...t,
level: e.level,
target: b(t.target)
})));
} else if (o) {
g = p["pino-worker"] || r(__dirname, "worker.js");
y.pipelines = [ o.map(e => ({
...e,
target: b(e.target)
})) ];
}
if (l) {
y.levels = l;
}
if (f) {
y.dedupe = f;
}
y.pinoWillSendConfig = true;
return a(b(g), y, u, d);
function b(t) {
t = p[t] || t;
if (n(t) || t.indexOf("file://") === 0) {
return t;
}
if (t === "pino/file") {
return r(__dirname, "..", "file.js");
}
let s;
for (const r of m) {
try {
const n = r === "node:repl" ? process.cwd() + i : r;
s = e(n).resolve(t);
break;
} catch (e) {
continue;
}
}
if (!s) {
throw new Error(`unable to determine transport target for "${t}"`);
}
return s;
}
}
nn = h;
return nn;
}
const cn = A.default;
const ln = Yt;
const {mapHttpRequest: an, mapHttpResponse: fn} = De;
const un = Tr;
const hn = Gr;
const {lsCacheSym: dn, chindingsSym: yn, writeSym: mn, serializersSym: pn, formatOptsSym: gn, endSym: bn, stringifiersSym: vn, stringifySym: wn, stringifySafeSym: Sn, wildcardFirstSym: On, nestedKeySym: En, formattersSym: _n, messageKeySym: Ln, errorKeySym: jn, nestedKeyStrSym: xn, msgPrefixSym: kn} = At;
const {isMainThread: An} = M.default;
const Tn = on();
const Cn = cn.tracingChannel("pino_asJson");
function Bn() {}
function Dn(e, t) {
if (!t) return r;
return function n(...i) {
t.call(this, i, r, e);
};
function r(t, ...r) {
if (typeof t === "object") {
let n = t;
if (t !== null) {
if (t.method && t.headers && t.socket) {
t = an(t);
} else if (typeof t.setHeader === "function") {
t = fn(t);
}
}
let i;
if (n === null && r.length === 0) {
i = [ null ];
} else {
n = r.shift();
i = r;
}
if (typeof this[kn] === "string" && n !== undefined && n !== null) {
n = this[kn] + n;
}
this[mn](t, ln(n, i, this[gn]), e);
} else {
let n = t === undefined ? r.shift() : t;
if (typeof this[kn] === "string" && n !== undefined && n !== null) {
n = this[kn] + n;
}
this[mn](null, ln(n, r, this[gn]), e);
}
}
}
function $n(e) {
let t = "";
let r = 0;
let n = false;
let i = 255;
const s = e.length;
if (s > 100) {
return JSON.stringify(e);
}
for (var o = 0; o < s && i >= 32; o++) {
i = e.charCodeAt(o);
if (i === 34 || i === 92) {
t += e.slice(r, o) + "\\";
r = o;
n = true;
}
}
if (!n) {
t = e;
} else {
t += e.slice(r);
}
return i < 32 ? JSON.stringify(e) : '"' + t + '"';
}
function Mn(e, t, r, n) {
if (Cn.hasSubscribers === false) {
return Pn.call(this, e, t, r, n);
}
const i = {
instance: this,
arguments: arguments
};
return Cn.traceSync(Pn, i, this, e, t, r, n);
}
function Pn(e, t, r, n) {
const i = this[wn];
const s = this[Sn];
const o = this[vn];
const c = this[bn];
const l = this[yn];
const a = this[pn];
const f = this[_n];
const u = this[Ln];
const h = this[jn];
let d = this[dn][r] + n;
d = d + l;
let y;
if (f.log) {
e = f.log(e);
}
const m = o[On];
let p = "";
for (const t in e) {
y = e[t];
if (Object.prototype.hasOwnProperty.call(e, t) && y !== undefined) {
if (a[t]) {
y = a[t](y);
} else if (t === h && a.err) {
y = a.err(y);
}
const e = o[t] || m;
switch (typeof y) {
case "undefined":
case "function":
continue;
case "number":
if (Number.isFinite(y) === false) {
y = null;
}
case "boolean":
if (e) y = e(y);
break;
case "string":
y = (e || $n)(y);
break;
default:
y = (e || i)(y, s);
}
if (y === undefined) continue;
const r = $n(t);
p += "," + r + ":" + y;
}
}
let g = "";
if (t !== undefined) {
y = a[u] ? a[u](t) : t;
const e = o[u] || m;
switch (typeof y) {
case "function":
break;
case "number":
if (Number.isFinite(y) === false) {
y = null;
}
case "boolean":
if (e) y = e(y);
g = ',"' + u + '":' + y;
break;
case "string":
y = (e || $n)(y);
g = ',"' + u + '":' + y;
break;
default:
y = (e || i)(y, s);
g = ',"' + u + '":' + y;
}
}
if (this[En] && p) {
return d + this[xn] + p.slice(1) + "}" + g + c;
} else {
return d + p + g + c;
}
}
function Nn(e, t) {
let r;
let n = e[yn];
const i = e[wn];
const s = e[Sn];
const o = e[vn];
const c = o[On];
const l = e[pn];
const a = e[_n].bindings;
t = a(t);
for (const e in t) {
r = t[e];
const a = (e.length < 5 || e !== "level" && e !== "serializers" && e !== "formatters" && e !== "customLevels") && t.hasOwnProperty(e) && r !== undefined;
if (a === true) {
r = l[e] ? l[e](r) : r;
r = (o[e] || c || i)(r, s);
if (r === undefined) continue;
n += ',"' + e + '":' + r;
}
}
return n;
}
function Fn(e) {
return e.write !== e.constructor.prototype.write;
}
function In(e) {
const t = new un(e);
t.on("error", r);
if (!e.sync && An) {
hn.register(t, Rn);
t.on("close", function() {
hn.unregister(t);
});
}
return t;
function r(e) {
if (e.code === "EPIPE") {
t.write = Bn;
t.end = Bn;
t.flushSync = Bn;
t.destroy = Bn;
return;
}
t.removeListener("error", r);
t.emit("error", e);
}
}
function Rn(e, t) {
if (e.destroyed) {
return;
}
if (t === "beforeExit") {
e.flush();
e.on("drain", function() {
e.end();
});
} else {
e.flushSync();
}
}
function Kn(e) {
return function t(r, n, i = {}, s) {
if (typeof i === "string") {
s = In({
dest: i
});
i = {};
} else if (typeof s === "string") {
if (i && i.transport) {
throw Error("only one of option.transport or stream can be specified");
}
s = In({
dest: s
});
} else if (i instanceof un || i.writable || i._writableState) {
s = i;
i = {};
} else if (i.transport) {
if (i.transport instanceof un || i.transport.writable || i.transport._writableState) {
throw Error("option.transport do not allow stream, please pass to option directly. e.g. pino(transport)");
}
if (i.transport.targets && i.transport.targets.length && i.formatters && typeof i.formatters.level === "function") {
throw Error("option.transport.targets do not allow custom level formatters");
}
let e;
if (i.customLevels) {
e = i.useOnlyCustomLevels ? i.customLevels : Object.assign({}, i.levels, i.customLevels);
}
s = Tn({
caller: n,
...i.transport,
levels: e
});
}
i = Object.assign({}, e, i);
i.serializers = Object.assign({}, e.serializers, i.serializers);
i.formatters = Object.assign({}, e.formatters, i.formatters);
if (i.prettyPrint) {
throw new Error("prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)");
}
const {enabled: o, onChild: c} = i;
if (o === false) i.level = "silent";
if (!c) i.onChild = Bn;
if (!s) {
if (!Fn(process.stdout)) {
s = In({
fd: process.stdout.fd || 1
});
} else {
s = process.stdout;
}
}
return {
opts: i,
stream: s
};
};
}
function zn(e, t) {
try {
return JSON.stringify(e);
} catch (r) {
try {
const r = t || this[Sn];
return r(e);
} catch (e) {
return '"[unable to serialize, circular reference is too complex to analyze]"';
}
}
}
function Wn(e, t, r) {
return {
level: e,
bindings: t,
log: r
};
}
function qn(e) {
const t = Number(e);
if (typeof e === "string" && Number.isFinite(t)) {
return t;
}
if (e === undefined) {
return 1;
}
return e;
}
var Gn = {
noop: Bn,
buildSafeSonicBoom: In,
asChindings: Nn,
asJson: Mn,
genLog: Dn,
createArgsNormalizer: Kn,
stringify: zn,
buildFormatters: Wn,
normalizeDestFileDescriptor: qn
};
const Vn = {
trace: 10,
debug: 20,
info: 30,
warn: 40,
error: 50,
fatal: 60
};
const Un = {
ASC: "ASC",
DESC: "DESC"
};
var Jn = {
DEFAULT_LEVELS: Vn,
SORTING_ORDER: Un
};
const {lsCacheSym: Hn, levelValSym: Yn, useOnlyCustomLevelsSym: Xn, streamSym: Zn, formattersSym: Qn, hooksSym: ei, levelCompSym: ti} = At;
const {noop: ri, genLog: ni} = Gn;
const {DEFAULT_LEVELS: ii, SORTING_ORDER: si} = Jn;
const oi = {
fatal: e => {
const t = ni(ii.fatal, e);
return function(...e) {
const r = this[Zn];
t.call(this, ...e);
if (typeof r.flushSync === "function") {
try {
r.flushSync();
} catch (e) {}
}
};
},
error: e => ni(ii.error, e),
warn: e => ni(ii.warn, e),
info: e => ni(ii.info, e),
debug: e => ni(ii.debug, e),
trace: e => ni(ii.trace, e)
};
const ci = Object.keys(ii).reduce((e, t) => {
e[ii[t]] = t;
return e;
}, {});
const li = Object.keys(ci).reduce((e, t) => {
e[t] = '{"level":' + Number(t);
return e;
}, {});
function ai(e) {
const t = e[Qn].level;
const {labels: r} = e.levels;
const n = {};
for (const e in r) {
const i = t(r[e], Number(e));
n[e] = JSON.stringify(i).slice(0, -1);
}
e[Hn] = n;
return e;
}
function fi(e, t) {
if (t) {
return false;
}
switch (e) {
case "fatal":
case "error":
case "warn":
case "info":
case "debug":
case "trace":
return true;
default:
return false;
}
}
function ui(e) {
const {labels: t, values: r} = this.levels;
if (typeof e === "number") {
if (t[e] === undefined) throw Error("unknown level value" + e);
e = t[e];
}
if (r[e] === undefined) throw Error("unknown level " + e);
const n = this[Yn];
const i = this[Yn] = r[e];
const s = this[Xn];
const o = this[ti];
const c = this[ei].logMethod;
for (const e in r) {
if (o(r[e], i) === false) {
this[e] = ri;
continue;
}
this[e] = fi(e, s) ? oi[e](c) : ni(r[e], c);
}
this.emit("level-change", e, i, t[n], n, this);
}
function hi(e) {
const {levels: t, levelVal: r} = this;
return t && t.labels ? t.labels[r] : "";
}
function di(e) {
const {values: t} = this.levels;
const r = t[e];
return r !== undefined && this[ti](r, this[Yn]);
}
function yi(e, t, r) {
if (e === si.DESC) {
return t <= r;
}
return t >= r;
}
function mi(e) {
if (typeof e === "string") {
return yi.bind(null, e);
}
return e;
}
function pi(e = null, t = false) {
const r = e ? Object.keys(e).reduce((t, r) => {
t[e[r]] = r;
return t;
}, {}) : null;
const n = Object.assign(Object.create(Object.prototype, {
Infinity: {
value: "silent"
}
}), t ? null : ci, r);
const i = Object.assign(Object.create(Object.prototype, {
silent: {
value: Infinity
}
}), t ? null : ii, e);
return {
labels: n,
values: i
};
}
function gi(e, t, r) {
if (typeof e === "number") {
const n = [].concat(Object.keys(t || {}).map(e => t[e]), r ? [] : Object.keys(ci).map(e => +e), Infinity);
if (!n.includes(e)) {
throw Error(`default level:${e} must be included in custom levels`);
}
return;
}
const n = Object.assign(Object.create(Object.prototype, {
silent: {
value: Infinity
}
}), r ? null : ii, t);
if (!(e in n)) {
throw Error(`default level:${e} must be included in custom levels`);
}
}
function bi(e, t) {
const {labels: r, values: n} = e;
for (const e in t) {
if (e in n) {
throw Error("levels cannot be overridden");
}
if (t[e] in r) {
throw Error("pre-existing level values cannot be used for new levels");
}
}
}
function vi(e) {
if (typeof e === "function") {
return;
}
if (typeof e === "string" && Object.values(si).includes(e)) {
return;
}
throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type');
}
var wi = {
initialLsCache: li,
genLsCache: ai,
levelMethods: oi,
getLevel: hi,
setLevel: ui,
isLevelEnabled: di,
mappings: pi,
assertNoLevelCollisions: bi,
assertDefaultLevelFound: gi,
genLevelComparison: mi,
assertLevelComparison: vi
};
var Si = {
version: "10.1.0"
};
const {EventEmitter: Oi} = k.default;
const {lsCacheSym: Ei, levelValSym: _i, setLevelSym: Li, getLevelSym: ji, chindingsSym: xi, mixinSym: ki, asJsonSym: Ai, writeSym: Ti, mixinMergeStrategySym: Ci, timeSym: Bi, timeSliceIndexSym: Di, streamSym: $i, serializersSym: Mi, formattersSym: Pi, errorKeySym: Ni, messageKeySym: Fi, useOnlyCustomLevelsSym: Ii, needsMetadataGsym: Ri, redactFmtSym: Ki, stringifySym: zi, formatOptsSym: Wi, stringifiersSym: qi, msgPrefixSym: Gi, hooksSym: Vi} = At;
const {getLevel: Ui, setLevel: Ji, isLevelEnabled: Hi, mappings: Yi, initialLsCache: Xi, genLsCache: Zi, assertNoLevelCollisions: Qi} = wi;
const {asChindings: es, asJson: ts, buildFormatters: rs, stringify: ns, noop: is} = Gn;
const {version: ss} = Si;
const os = Ft;
const cs = class Pino {};
const ls = {
constructor: cs,
child: us,
bindings: hs,
setBindings: ds,
flush: ps,
isLevelEnabled: Hi,
version: ss,
get level() {
return this[ji]();
},
set level(e) {
this[Li](e);
},
get levelVal() {
return this[_i];
},
set levelVal(e) {
throw Error("levelVal is read-only");
},
get msgPrefix() {
return this[Gi];
},
get [Symbol.toStringTag]() {
return "Pino";
},
[Ei]: Xi,
[Ti]: ms,
[Ai]: ts,
[ji]: Ui,
[Li]: Ji
};
Object.setPrototypeOf(ls, Oi.prototype);
var as = function() {
return Object.create(ls);
};
const fs = e => e;
function us(e, t) {
if (!e) {
throw Error("missing bindings for child Pino");
}
const r = this[Mi];
const n = this[Pi];
const i = Object.create(this);
if (t == null) {
if (i[Pi].bindings !== fs) {
i[Pi] = rs(n.level, fs, n.log);
}
i[xi] = es(i, e);
if (this.onChild !== is) {
this.onChild(i);
}
return i;
}
if (t.hasOwnProperty("serializers") === true) {
i[Mi] = Object.create(null);
for (const e in r) {
i[Mi][e] = r[e];
}
const e = Object.getOwnPropertySymbols(r);
for (var s = 0; s < e.length; s++) {
const t = e[s];
i[Mi][t] = r[t];
}
for (const e in t.serializers) {
i[Mi][e] = t.serializers[e];
}
const n = Object.getOwnPropertySymbols(t.serializers);
for (var o = 0; o < n.length; o++) {
const e = n[o];
i[Mi][e] = t.serializers[e];
}
} else i[Mi] = r;
if (t.hasOwnProperty("formatters")) {
const {level: e, bindings: r, log: s} = t.formatters;
i[Pi] = rs(e || n.level, r || fs, s || n.log);
} else {
i[Pi] = rs(n.level, fs, n.log);
}
if (t.hasOwnProperty("customLevels") === true) {
Qi(this.levels, t.customLevels);
i.levels = Yi(t.customLevels, i[Ii]);
Zi(i);
}
if (typeof t.redact === "object" && t.redact !== null || Array.isArray(t.redact)) {
i.redact = t.redact;
const e = os(i.redact, ns);
const r = {
stringify: e[Ki]
};
i[zi] = ns;
i[qi] = e;
i[Wi] = r;
}
if (typeof t.msgPrefix === "string") {
i[Gi] = (this[Gi] || "") + t.msgPrefix;
}
i[xi] = es(i, e);
if (t.level !== undefined && t.level !== this.level || t.hasOwnProperty("customLevels")) {
const e = t.level || this.level;
i[Li](e);
}
this.onChild(i);
return i;
}
function hs() {
const e = this[xi];
const t = `{${e.substr(1)}}`;
const r = JSON.parse(t);
delete r.pid;
delete r.hostname;
return r;
}
function ds(e) {
const t = es(this, e);
this[xi] = t;
}
function ys(e, t) {
return Object.assign(t, e);
}
function ms(e, t, r) {
const n = this[Bi]();
const i = this[ki];
const s = this[Ni];
const o = this[Fi];
const c = this[Ci] || ys;
let l;
const a = this[Vi].streamWrite;
if (e === undefined || e === null) {
l = {};
} else if (e instanceof Error) {
l = {
[s]: e
};
if (t === undefined) {
t = e.message;
}
} else {
l = e;
if (t === undefined && e[o] === undefined && e[s]) {
t = e[s].message;
}
}
if (i) {
l = c(l, i(l, r, this));
}
const f = this[Ai](l, t, r, n);
const u = this[$i];
if (u[Ri] === true) {
u.lastLevel = r;
u.lastObj = l;
u.lastMsg = t;
u.lastTime = n.slice(this[Di]);
u.lastLogger = this;
}
u.write(a ? a(f) : f);
}
function ps(e) {
if (e != null && typeof e !== "function") {
throw Error("callback must be a function");
}
const t = this[$i];
if (typeof t.flush === "function") {
t.flush(e || is);
} else if (e) e();
}
var gs = {
exports: {}
};
gs.exports;
(function(e, t) {
const {hasOwnProperty: r} = Object.prototype;
const n = g();
n.configure = g;
n.stringify = n;
n.default = n;
t.stringify = n;
t.configure = g;
e.exports = n;
const i = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
function s(e) {
if (e.length < 5e3 && !i.test(e)) {
return `"${e}"`;
}
return JSON.stringify(e);
}
function o(e, t) {
if (e.length > 200 || t) {
return e.sort(t);
}
for (let t = 1; t < e.length; t++) {
const r = e[t];
let n = t;
while (n !== 0 && e[n - 1] > r) {
e[n] = e[n - 1];
n--;
}
e[n] = r;
}
return e;
}
const c = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array)), Symbol.toStringTag).get;
function l(e) {
return c.call(e) !== undefined && e.length !== 0;
}
function a(e, t, r) {
if (e.length < r) {
r = e.length;
}
const n = t === "," ? "" : " ";
let i = `"0":${n}${e[0]}`;
for (let s = 1; s < r; s++) {
i += `${t}"${s}":${n}${e[s]}`;
}
return i;
}
function f(e) {
if (r.call(e, "circularValue")) {
const t = e.circularValue;
if (typeof t === "string") {
return `"${t}"`;
}
if (t == null) {
return t;
}
if (t === Error || t === TypeError) {
return {
toString() {
throw new TypeError("Converting circular structure to JSON");
}
};
}
throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
}
return '"[Circular]"';
}
function u(e) {
let t;
if (r.call(e, "deterministic")) {
t = e.deterministic;
if (typeof t !== "boolean" && typeof t !== "function") {
throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
}
}
return t === undefined ? true : t;
}
function h(e, t) {
let n;
if (r.call(e, t)) {
n = e[t];
if (typeof n !== "boolean") {
throw new TypeError(`The "${t}" argument must be of type boolean`);
}
}
return n === undefined ? true : n;
}
function d(e, t) {
let n;
if (r.call(e, t)) {
n = e[t];
if (typeof n !== "number") {
throw new TypeError(`The "${t}" argument must be of type number`);
}
if (!Number.isInteger(n)) {
throw new TypeError(`The "${t}" argument must be an integer`);
}
if (n < 1) {
throw new RangeError(`The "${t}" argument must be >= 1`);
}
}
return n === undefined ? Infinity : n;
}
function y(e) {
if (e === 1) {
return "1 item";
}
return `${e} items`;
}
function m(e) {
const t = new Set;
for (const r of e) {
if (typeof r === "string" || typeof r === "number") {
t.add(String(r));
}
}
return t;
}
function p(e) {
if (r.call(e, "strict")) {
const t = e.strict;
if (typeof t !== "boolean") {
throw new TypeError('The "strict" argument must be of type boolean');
}
if (t) {
return e => {
let t = `Object can not safely be stringified. Received type ${typeof e}`;
if (typeof e !== "function") t += ` (${e.toString()})`;
throw new Error(t);
};
}
}
}
function g(e) {
e = {
...e
};
const t = p(e);
if (t) {
if (e.bigint === undefined) {
e.bigint = false;
}
if (!("circularValue" in e)) {
e.circularValue = Error;
}
}
const r = f(e);
const n = h(e, "bigint");
const i = u(e);
const c = typeof i === "function" ? i : undefined;
const g = d(e, "maximumDepth");
const b = d(e, "maximumBreadth");
function v(e, a, f, u, h, d) {
let m = a[e];
if (typeof m === "object" && m !== null && typeof m.toJSON === "function") {
m = m.toJSON(e);
}
m = u.call(a, e, m);
switch (typeof m) {
case "string":
return s(m);
case "object":
{
if (m === null) {
return "null";
}
if (f.indexOf(m) !== -1) {
return r;
}
let e = "";
let t = ",";
const n = d;
if (Array.isArray(m)) {
if (m.length === 0) {
return "[]";
}
if (g < f.length + 1) {
return '"[Array]"';
}
f.push(m);
if (h !== "") {
d += h;
e += `\n${d}`;
t = `,\n${d}`;
}
const r = Math.min(m.length, b);
let i = 0;
for (;i < r - 1; i++) {
const r = v(String(i), m, f, u, h, d);
e += r !== undefined ? r : "null";
e += t;
}
const s = v(String(i), m, f, u, h, d);
e += s !== undefined ? s : "null";
if (m.length - 1 > b) {
const r = m.length - b - 1;
e += `${t}"... ${y(r)} not stringified"`;
}
if (h !== "") {
e += `\n${n}`;
}
f.pop();
return `[${e}]`;
}
let a = Object.keys(m);
const p = a.length;
if (p === 0) {
return "{}";
}
if (g < f.length + 1) {
return '"[Object]"';
}
let w = "";
let S = "";
if (h !== "") {
d += h;
t = `,\n${d}`;
w = " ";
}
const O = Math.min(p, b);
if (i && !l(m)) {
a = o(a, c);
}
f.push(m);
for (let r = 0; r < O; r++) {
const n = a[r];
const i = v(n, m, f, u, h, d);
if (i !== undefined) {
e += `${S}${s(n)}:${w}${i}`;
S = t;
}
}
if (p > b) {
const r = p - b;
e += `${S}"...":${w}"${y(r)} not stringified"`;
S = t;
}
if (h !== "" && S.length > 1) {
e = `\n${d}${e}\n${n}`;
}
f.pop();
return `{${e}}`;
}
case "number":
return isFinite(m) ? String(m) : t ? t(m) : "null";
case "boolean":
return m === true ? "true" : "false";
case "undefined":
return undefined;
case "bigint":
if (n) {
return String(m);
}
default:
return t ? t(m) : undefined;
}
}
function w(e, i, o, c, l, a) {
if (typeof i === "object" && i !== null && typeof i.toJSON === "function") {
i = i.toJSON(e);
}
switch (typeof i) {
case "string":
return s(i);
case "object":
{
if (i === null) {
return "null";
}
if (o.indexOf(i) !== -1) {
return r;
}
const e = a;
let t = "";
let n = ",";
if (Array.isArray(i)) {
if (i.length === 0) {
return "[]";
}
if (g < o.length + 1) {
return '"[Array]"';
}
o.push(i);
if (l !== "") {
a += l;
t += `\n${a}`;
n = `,\n${a}`;
}
const r = Math.min(i.length, b);
let s = 0;
for (;s < r - 1; s++) {
const e = w(String(s), i[s], o, c, l, a);
t += e !== undefined ? e : "null";
t += n;
}
const f = w(String(s), i[s], o, c, l, a);
t += f !== undefined ? f : "null";
if (i.length - 1 > b) {
const e = i.length - b - 1;
t += `${n}"... ${y(e)} not stringified"`;
}
if (l !== "") {
t += `\n${e}`;
}
o.pop();
return `[${t}]`;
}
o.push(i);
let f = "";
if (l !== "") {
a += l;
n = `,\n${a}`;
f = " ";
}
let u = "";
for (const e of c) {
const r = w(e, i[e], o, c, l, a);
if (r !== undefined) {
t += `${u}${s(e)}:${f}${r}`;
u = n;
}
}
if (l !== "" && u.length > 1) {
t = `\n${a}${t}\n${e}`;
}
o.pop();
return `{${t}}`;
}
case "number":
return isFinite(i) ? String(i) : t ? t(i) : "null";
case "boolean":
return i === true ? "true" : "false";
case "undefined":
return undefined;
case "bigint":
if (n) {
return String(i);
}
default:
return t ? t(i) : undefined;
}
}
function S(e, f, u, h, d) {
switch (typeof f) {
case "string":
return s(f);
case "object":
{
if (f === null) {
return "null";
}
if (typeof f.toJSON === "function") {
f = f.toJSON(e);
if (typeof f !== "object") {
return S(e, f, u, h, d);
}
if (f === null) {
return "null";
}
}
if (u.indexOf(f) !== -1) {
return r;
}
const t = d;
if (Array.isArray(f)) {
if (f.length === 0) {
return "[]";
}
if (g < u.length + 1) {
return '"[Array]"';
}
u.push(f);
d += h;
let e = `\n${d}`;
const r = `,\n${d}`;
const n = Math.min(f.length, b);
let i = 0;
for (;i < n - 1; i++) {
const t = S(String(i), f[i], u, h, d);
e += t !== undefined ? t : "null";
e += r;
}
const s = S(String(i), f[i], u, h, d);
e += s !== undefined ? s : "null";
if (f.length - 1 > b) {
const t = f.length - b - 1;
e += `${r}"... ${y(t)} not stringified"`;
}
e += `\n${t}`;
u.pop();
return `[${e}]`;
}
let n = Object.keys(f);
const m = n.length;
if (m === 0) {
return "{}";
}
if (g < u.length + 1) {
return '"[Object]"';
}
d += h;
const p = `,\n${d}`;
let v = "";
let w = "";
let O = Math.min(m, b);
if (l(f)) {
v += a(f, p, b);
n = n.slice(f.length);
O -= f.length;
w = p;
}
if (i) {
n = o(n, c);
}
u.push(f);
for (let e = 0; e < O; e++) {
const t = n[e];
const r = S(t, f[t], u, h, d);
if (r !== undefined) {
v += `${w}${s(t)}: ${r}`;
w = p;
}
}
if (m > b) {
const e = m - b;
v += `${w}"...": "${y(e)} not stringified"`;
w = p;
}
if (w !== "") {
v = `\n${d}${v}\n${t}`;
}
u.pop();
return `{${v}}`;
}
case "number":
return isFinite(f) ? String(f) : t ? t(f) : "null";
case "boolean":
return f === true ? "true" : "false";
case "undefined":
return undefined;
case "bigint":
if (n) {
return String(f);
}
default:
return t ? t(f) : undefined;
}
}
function O(e, f, u) {
switch (typeof f) {
case "string":
return s(f);
case "object":
{
if (f === null) {
return "null";
}
if (typeof f.toJSON === "function") {
f = f.toJSON(e);
if (typeof f !== "object") {
return O(e, f, u);
}
if (f === null) {
return "null";
}
}
if (u.indexOf(f) !== -1) {
return r;
}
let t = "";
const n = f.length !== undefined;
if (n && Array.isArray(f)) {
if (f.length === 0) {
return "[]";
}
if (g < u.length + 1) {
return '"[Array]"';
}
u.push(f);
const e = Math.min(f.length, b);
let r = 0;
for (;r < e - 1; r++) {
const e = O(String(r), f[r], u);
t += e !== undefined ? e : "null";
t += ",";
}
const n = O(String(r), f[r], u);
t += n !== undefined ? n : "null";
if (f.length - 1 > b) {
const e = f.length - b - 1;
t += `,"... ${y(e)} not stringified"`;
}
u.pop();
return `[${t}]`;
}
let h = Object.keys(f);
const d = h.length;
if (d === 0) {
return "{}";
}
if (g < u.length + 1) {
return '"[Object]"';
}
let m = "";
let p = Math.min(d, b);
if (n && l(f)) {
t += a(f, ",", b);
h = h.slice(f.length);
p -= f.length;
m = ",";
}
if (i) {
h = o(h, c);
}
u.push(f);
for (let e = 0; e < p; e++) {
const r = h[e];
const n = O(r, f[r], u);
if (n !== undefined) {
t += `${m}${s(r)}:${n}`;
m = ",";
}
}
if (d > b) {
const e = d - b;
t += `${m}"...":"${y(e)} not stringified"`;
}
u.pop();
return `{${t}}`;
}
case "number":
return isFinite(f) ? String(f) : t ? t(f) : "null";
case "boolean":
return f === true ? "true" : "false";
case "undefined":
return undefined;
case "bigint":
if (n) {
return String(f);
}
default:
return t ? t(f) : undefined;
}
}
function E(e, t, r) {
if (arguments.length > 1) {
let n = "";
if (typeof r === "number") {
n = " ".repeat(Math.min(r, 10));
} else if (typeof r === "string") {
n = r.slice(0, 10);
}
if (t != null) {
if (typeof t === "function") {
return v("", {
"": e
}, [], t, n, "");
}
if (Array.isArray(t)) {
return w("", e, [], m(t), n, "");
}
}
if (n.length !== 0) {
return S("", e, [], n, "");
}
}
return O("", e, []);
}
return E;
}
})(gs, gs.exports);
var bs = gs.exports;
var vs;
var ws;
function Ss() {
if (ws) return vs;
ws = 1;
const e = Symbol.for("pino.metadata");
const {DEFAULT_LEVELS: t} = Jn;
const r = t.info;
function n(n, l) {
n = n || [];
l = l || {
dedupe: false
};
const a = Object.create(t);
a.silent = Infinity;
if (l.levels && typeof l.levels === "object") {
Object.keys(l.levels).forEach(e => {
a[e] = l.levels[e];
});
}
const f = {
write: u,
add: y,
remove: m,
emit: h,
flushSync: d,
end: p,
minLevel: 0,
lastId: 0,
streams: [],
clone: g,
[e]: true,
streamLevels: a
};
if (Array.isArray(n)) {
n.forEach(y, f);
} else {
y.call(f, n);
}
n = null;
return f;
function u(t) {
let r;
const n = this.lastLevel;
const {streams: i} = this;
let a = 0;
let f;
for (let u = s(i.length, l.dedupe); c(u, i.length, l.dedupe); u = o(u, l.dedupe)) {
r = i[u];
if (r.level <= n) {
if (a !== 0 && a !== r.level) {
break;
}
f = r.stream;
if (f[e]) {
const {lastTime: e, lastMsg: t, lastObj: r, lastLogger: i} = this;
f.lastLevel = n;
f.lastTime = e;
f.lastMsg = t;
f.lastObj = r;
f.lastLogger = i;
}
f.write(t);
if (l.dedupe) {
a = r.level;
}
} else if (!l.dedupe) {
break;
}
}
}
function h(...e) {
for (const {stream: t} of this.streams) {
if (typeof t.emit === "function") {
t.emit(...e);
}
}
}
function d() {
for (const {stream: e} of this.streams) {
if (typeof e.flushSync === "function") {
e.flushSync();
}
}
}
function y(e) {
if (!e) {
return f;
}
const t = typeof e.write === "function" || e.stream;
const n = e.write ? e : e.stream;
if (!t) {
throw Error("stream object needs to implement either StreamEntry or DestinationStream interface");
}
const {streams: s, streamLevels: o} = this;
let c;
if (typeof e.levelVal === "number") {
c = e.levelVal;
} else if (typeof e.level === "string") {
c = o[e.level];
} else if (typeof e.level === "number") {
c = e.level;
} else {
c = r;
}
const l = {
stream: n,
level: c,
levelVal: undefined,
id: ++f.lastId
};
s.unshift(l);
s.sort(i);
this.minLevel = s[0].level;
return f;
}
function m(e) {
const {streams: t} = this;
const r = t.findIndex(t => t.id === e);
if (r >= 0) {
t.splice(r, 1);
t.sort(i);
this.minLevel = t.length > 0 ? t[0].level : -1;
}
return f;
}
function p() {
for (const {stream: e} of this.streams) {
if (typeof e.flushSync === "function") {
e.flushSync();
}
e.end();
}
}
function g(t) {
const r = new Array(this.streams.length);
for (let e = 0; e < r.length; e++) {
r[e] = {
level: t,
stream: this.streams[e].stream
};
}
return {
write: u,
add: y,
remove: m,
minLevel: t,
streams: r,
clone: g,
emit: h,
flushSync: d,
[e]: true
};
}
}
function i(e, t) {
return e.level - t.level;
}
function s(e, t) {
return t ? e - 1 : 0;
}
function o(e, t) {
return t ? e - 1 : e + 1;
}
function c(e, t, r) {
return r ? e >= 0 : e < t;
}
vs = n;
return vs;
}
G.exports;
const Os = x.default;
const Es = De;
const _s = Me;
const Ls = Ft;
const js = Jt;
const xs = as;
const ks = At;
const {configure: As} = bs;
const {assertDefaultLevelFound: Ts, mappings: Cs, genLsCache: Bs, genLevelComparison: Ds, assertLevelComparison: $s} = wi;
const {DEFAULT_LEVELS: Ms, SORTING_ORDER: Ps} = Jn;
const {createArgsNormalizer: Ns, asChindings: Fs, buildSafeSonicBoom: Is, buildFormatters: Rs, stringify: Ks, normalizeDestFileDescriptor: zs, noop: Ws} = Gn;
const {version: qs} = Si;
const {chindingsSym: Gs, redactFmtSym: Vs, serializersSym: Us, timeSym: Js, timeSliceIndexSym: Hs, streamSym: Ys, stringifySym: Xs, stringifySafeSym: Zs, stringifiersSym: Qs, setLevelSym: eo, endSym: to, formatOptsSym: ro, messageKeySym: no, errorKeySym: io, nestedKeySym: so, mixinSym: oo, levelCompSym: co, useOnlyCustomLevelsSym: lo, formattersSym: ao, hooksSym: fo, nestedKeyStrSym: uo, mixinMergeStrategySym: ho, msgPrefixSym: yo} = ks;
const {epochTime: mo, nullTime: po} = js;
const {pid: go} = process;
const bo = Os.hostname();
const vo = Es.err;
const wo = {
level: "info",
levelComparison: Ps.ASC,
levels: Ms,
messageKey: "msg",
errorKey: "err",
nestedKey: null,
enabled: true,
base: {
pid: go,
hostname: bo
},
serializers: Object.assign(Object.create(null), {
err: vo
}),
formatters: Object.assign(Object.create(null), {
bindings(e) {
return e;
},
level(e, t) {
return {
level: t
};
}
}),
hooks: {
logMethod: undefined,
streamWrite: undefined
},
timestamp: mo,
name: undefined,
redact: null,
customLevels: null,
useOnlyCustomLevels: false,
depthLimit: 5,
edgeLimit: 100
};
const So = Ns(wo);
const Oo = Object.assign(Object.create(null), Es);
function Eo(...e) {
const t = {};
const {opts: r, stream: n} = So(t, _s(), ...e);
if (r.level && typeof r.level === "string" && Ms[r.level.toLowerCase()] !== undefined) r.level = r.level.toLowerCase();
const {redact: i, crlf: s, serializers: o, timestamp: c, messageKey: l, errorKey: a, nestedKey: f, base: u, name: h, level: d, customLevels: y, levelComparison: m, mixin: p, mixinMergeStrategy: g, useOnlyCustomLevels: b, formatters: v, hooks: w, depthLimit: S, edgeLimit: O, onChild: E, msgPrefix: _} = r;
const L = As({
maximumDepth: S,
maximumBreadth: O
});
const j = Rs(v.level, v.bindings, v.log);
const x = Ks.bind({
[Zs]: L
});
const k = i ? Ls(i, x) : {};
const A = i ? {
stringify: k[Vs]
} : {
stringify: x
};
const T = "}" + (s ? "\r\n" : "\n");
const C = Fs.bind(null, {
[Gs]: "",
[Us]: o,
[Qs]: k,
[Xs]: Ks,
[Zs]: L,
[ao]: j
});
let B = "";
if (u !== null) {
if (h === undefined) {
B = C(u);
} else {
B = C(Object.assign({}, u, {
name: h
}));
}
}
const D = c instanceof Function ? c : c ? mo : po;
const $ = D().indexOf(":") + 1;
if (b && !y) throw Error("customLevels is required if useOnlyCustomLevels is set true");
if (p && typeof p !== "function") throw Error(`Unknown mixin type "${typeof p}" - expected "function"`);
if (_ && typeof _ !== "string") throw Error(`Unknown msgPrefix type "${typeof _}" - expected "string"`);
Ts(d, y, b);
const M = Cs(y, b);
if (typeof n.emit === "function") {
n.emit("message", {
code: "PINO_CONFIG",
config: {
levels: M,
messageKey: l,
errorKey: a
}
});
}
$s(m);
const P = Ds(m);
Object.assign(t, {
levels: M,
[co]: P,
[lo]: b,
[Ys]: n,
[Js]: D,
[Hs]: $,
[Xs]: Ks,
[Zs]: L,
[Qs]: k,
[to]: T,
[ro]: A,
[no]: l,
[io]: a,
[so]: f,
[uo]: f ? `,${JSON.stringify(f)}:{` : "",
[Us]: o,
[oo]: p,
[ho]: g,
[Gs]: B,
[ao]: j,
[fo]: w,
silent: Ws,
onChild: E,
[yo]: _
});
Object.setPrototypeOf(t, xs());
Bs(t);
t[eo](d);
return t;
}
G.exports = Eo;
var _o = G.exports.destination = (e = process.stdout.fd) => {
if (typeof e === "object") {
e.dest = zs(e.dest || process.stdout.fd);
return Is(e);
} else {
return Is({
dest: zs(e),
minLength: 0
});
}
};
G.exports.transport = on();
var Lo = G.exports.multistream = Ss();
G.exports.levels = Cs();
G.exports.stdSerializers = Oo;
G.exports.stdTimeFunctions = Object.assign({}, js);
G.exports.symbols = ks;
G.exports.version = qs;
G.exports.default = Eo;
var jo = G.exports.pino = Eo;
G.exports;
var xo = {
exports: {}
};
var ko = {};
Object.defineProperty(ko, "__esModule", {
value: true
});
var Ao = R.default;
function To(e) {
if (e && e.__esModule) return e;
var t = Object.create(null);
if (e) {
Object.keys(e).forEach(function(r) {
if (r !== "default") {
var n = Object.getOwnPropertyDescriptor(e, r);
Object.defineProperty(t, r, n.get ? n : {
enumerable: true,
get: function() {
return e[r];
}
});
}
});
}
t["default"] = e;
return Object.freeze(t);
}
var Co = To(Ao);
const {env: Bo = {}, argv: Do = [], platform: $o = ""} = typeof process === "undefined" ? {} : process;
const Mo = "NO_COLOR" in Bo || Do.includes("--no-color");
const Po = "FORCE_COLOR" in Bo || Do.includes("--color");
const No = $o === "win32";
const Fo = Bo.TERM === "dumb";
const Io = Co && Co.isatty && Co.isatty(1) && Bo.TERM && !Fo;
const Ro = "CI" in Bo && ("GITHUB_ACTIONS" in Bo || "GITLAB_CI" in Bo || "CIRCLECI" in Bo);
const Ko = !Mo && (Po || No && !Fo || Io || Ro);
const zo = (e, t, r, n, i = t.substring(0, e) + n, s = t.substring(e + r.length), o = s.indexOf(r)) => i + (o < 0 ? s : zo(o, s, r, n));
const Wo = (e, t, r, n, i) => e < 0 ? r + t + n : r + zo(e, t, n, i) + n;
const qo = (e, t, r = e, n = e.length + 1) => i => i || !(i === "" || i === undefined) ? Wo(("" + i).indexOf(t, n), i, e, t, r) : "";
const Go = (e, t, r) => qo(`[${e}m`, `[${t}m`, r);
const Vo = {
reset: Go(0, 0),
bold: Go(1, 22, "[22m[1m"),
dim: Go(2, 22, "[22m[2m"),
italic: Go(3, 23),
underline: Go(4, 24),
inverse: Go(7, 27),
hidden: Go(8, 28),
strikethrough: Go(9, 29),
black: Go(30, 39),
red: Go(31, 39),
green: Go(32, 39),
yellow: Go(33, 39),
blue: Go(34, 39),
magenta: Go(35, 39),
cyan: Go(36, 39),
white: Go(37, 39),
gray: Go(90, 39),
bgBlack: Go(40, 49),
bgRed: Go(41, 49),
bgGreen: Go(42, 49),
bgYellow: Go(43, 49),
bgBlue: Go(44, 49),
bgMagenta: Go(45, 49),
bgCyan: Go(46, 49),
bgWhite: Go(47, 49),
blackBright: Go(90, 39),
redBright: Go(91, 39),
greenBright: Go(92, 39),
yellowBright: Go(93, 39),
blueBright: Go(94, 39),
magentaBright: Go(95, 39),
cyanBright: Go(96, 39),
whiteBright: Go(97, 39),
bgBlackBright: Go(100, 49),
bgRedBright: Go(101, 49),
bgGreenBright: Go(102, 49),
bgYellowBright: Go(103, 49),
bgBlueBright: Go(104, 49),
bgMagentaBright: Go(105, 49),
bgCyanBright: Go(106, 49),
bgWhiteBright: Go(107, 49)
};
const Uo = ({useColor: e = Ko} = {}) => e ? Vo : Object.keys(Vo).reduce((e, t) => ({
...e,
[t]: String
}), {});
const {reset: Jo, bold: Ho, dim: Yo, italic: Xo, underline: Zo, inverse: Qo, hidden: ec, strikethrough: tc, black: rc, red: nc, green: ic, yellow: sc, blue: oc, magenta: cc, cyan: lc, white: ac, gray: fc, bgBlack: uc, bgRed: hc, bgGreen: dc, bgYellow: yc, bgBlue: mc, bgMagenta: pc, bgCyan: gc, bgWhite: bc, blackBright: vc, redBright: wc, greenBright: Sc, yellowBright: Oc, blueBright: Ec, magentaBright: _c, cyanBright: Lc, whiteBright: jc, bgBlackBright: xc, bgRedBright: kc, bgGreenBright: Ac, bgYellowBright: Tc, bgBlueBright: Cc, bgMagentaBright: Bc, bgCyanBright: Dc, bgWhiteBright: $c} = Uo();
ko.bgBlack = uc;
ko.bgBlackBright = xc;
ko.bgBlue = mc;
ko.bgBlueBright = Cc;
ko.bgCyan = gc;
ko.bgCyanBright = Dc;
ko.bgGreen = dc;
ko.bgGreenBright = Ac;
ko.bgMagenta = pc;
ko.bgMagentaBright = Bc;
ko.bgRed = hc;
ko.bgRedBright = kc;
ko.bgWhite = bc;
ko.bgWhiteBright = $c;
ko.bgYellow = yc;
ko.bgYellowBright = Tc;
ko.black = rc;
ko.blackBright = vc;
ko.blue = oc;
ko.blueBright = Ec;
ko.bold = Ho;
ko.createColors = Uo;
ko.cyan = lc;
ko.cyanBright = Lc;
ko.dim = Yo;
ko.gray = fc;
ko.green = ic;
ko.greenBright = Sc;
ko.hidden = ec;
ko.inverse = Qo;
ko.isColorSupported = Ko;
ko.italic = Xo;
ko.magenta = cc;
ko.magentaBright = _c;
ko.red = nc;
ko.redBright = wc;
ko.reset = Jo;
ko.strikethrough = tc;
ko.underline = Zo;
ko.white = ac;
ko.whiteBright = jc;
ko.yellow = sc;
ko.yellowBright = Oc;
var Mc = {
exports: {}
};
var Pc = Nc;
function Nc(e, t) {
if (e && t) return Nc(e)(t);
if (typeof e !== "function") throw new TypeError("need wrapper function");
Object.keys(e).forEach(function(t) {
r[t] = e[t];
});
return r;
function r() {
var t = new Array(arguments.length);
for (var r = 0; r < t.length; r++) {
t[r] = arguments[r];
}
var n = e.apply(this, t);
var i = t[t.length - 1];
if (typeof n === "function" && n !== i) {
Object.keys(i).forEach(function(e) {
n[e] = i[e];
});
}
return n;
}
}
Mc.exports;
var Fc = Pc;
Mc.exports = Fc(Ic);
Mc.exports.strict = Fc(Rc);
Ic.proto = Ic(function() {
Object.defineProperty(Function.prototype, "once", {
value: function() {
return Ic(this);
},
configurable: true
});
Object.defineProperty(Function.prototype, "onceStrict", {
value: function() {
return Rc(this);
},
configurable: true
});
});
function Ic(e) {
var t = function() {
if (t.called) return t.value;
t.called = true;
return t.value = e.apply(this, arguments);
};
t.called = false;
return t;
}
function Rc(e) {
var t = function() {
if (t.called) throw new Error(t.onceError);
t.called = true;
return t.value = e.apply(this, arguments);
};
var r = e.name || "Function wrapped with `once`";
t.onceError = r + " shouldn't be called more than once";
t.called = false;
return t;
}
var Kc = Mc.exports;
var zc = Kc;
var Wc = function() {};
var qc = p.commonjsGlobal.Bare ? queueMicrotask : process.nextTick.bind(process);
var Gc = function(e) {
return e.setHeader && typeof e.abort === "function";
};
var Vc = function(e) {
return e.stdio && Array.isArray(e.stdio) && e.stdio.length === 3;
};
var Uc = function(e, t, r) {
if (typeof t === "function") return Uc(e, null, t);
if (!t) t = {};
r = zc(r || Wc);
var n = e._writableState;
var i = e._readableState;
var s = t.readable || t.readable !== false && e.readable;
var o = t.writable || t.writable !== false && e.writable;
var c = false;
var l = function() {
if (!e.writable) a();
};
var a = function() {
o = false;
if (!s) r.call(e);
};
var f = function() {
s = false;
if (!o) r.call(e);
};
var u = function(t) {
r.call(e, t ? new Error("exited with error code: " + t) : null);
};
var h = function(t) {
r.call(e, t);
};
var d = function() {
qc(y);
};
var y = function() {
if (c) return;
if (s && !(i && (i.ended && !i.destroyed))) return r.call(e, new Error("premature close"));
if (o && !(n && (n.ended && !n.destroyed))) return r.call(e, new Error("premature close"));
};
var m = function() {
e.req.on("finish", a);
};
if (Gc(e)) {
e.on("complete", a);
e.on("abort", d);
if (e.req) m(); else e.on("request", m);
} else if (o && !n) {
e.on("end", l);
e.on("close", l);
}
if (Vc(e)) e.on("exit", u);
e.on("end", f);
e.on("finish", a);
if (t.error !== false) e.on("error", h);
e.on("close", d);
return function() {
c = true;
e.removeListener("complete", a);
e.removeListener("abort", d);
e.removeListener("request", m);
if (e.req) e.req.removeListener("finish", a);
e.removeListener("end", l);
e.removeListener("close", l);
e.removeListener("finish", a);
e.removeListener("exit", u);
e.removeListener("end", f);
e.removeListener("error", h);
e.removeListener("close", d);
};
};
exports.endOfStream = Uc;
var Jc = Kc;
var Hc = exports.endOfStream;
var Yc;
try {
Yc = require("fs");
} catch (e) {}
var Xc = function() {};
var Zc = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
var Qc = function(e) {
return typeof e === "function";
};
var el = function(e) {
if (!Zc) return false;
if (!Yc) return false;
return (e instanceof (Yc.ReadStream || Xc) || e instanceof (Yc.WriteStream || Xc)) && Qc(e.close);
};
var tl = function(e) {
return e.setHeader && Qc(e.abort);
};
var rl = function(e, t, r, n) {
n = Jc(n);
var i = false;
e.on("close", function() {
i = true;
});
Hc(e, {
readable: t,
writable: r
}, function(e) {
if (e) return n(e);
i = true;
n();
});
var s = false;
return function(t) {
if (i) return;
if (s) return;
s = true;
if (el(e)) return e.close(Xc);
if (tl(e)) return e.abort();
if (Qc(e.destroy)) return e.destroy();
n(t || new Error("stream was destroyed"));
};
};
var nl = function(e) {
e();
};
var il = function(e, t) {
return e.pipe(t);
};
var sl = function() {
var e = Array.prototype.slice.call(arguments);
var t = Qc(e[e.length - 1] || Xc) && e.pop() || Xc;
if (Array.isArray(e[0])) e = e[0];
if (e.length < 2) throw new Error("pump requires two streams per minimum");
var r;
var n = e.map(function(i, s) {
var o = s < e.length - 1;
var c = s > 0;
return rl(i, o, c, function(e) {
if (!r) r = e;
if (e) n.forEach(nl);
if (o) return;
n.forEach(nl);
t(r);
});
});
return e.reduce(il);
};
exports.pump_1 = sl;
const {Transform: ol} = z.default;
const {StringDecoder: cl} = W.default;
const ll = Symbol("last");
const al = Symbol("decoder");
function fl(e, t, r) {
let n;
if (this.overflow) {
const t = this[al].write(e);
n = t.split(this.matcher);
if (n.length === 1) return r();
n.shift();
this.overflow = false;
} else {
this[ll] += this[al].write(e);
n = this[ll].split(this.matcher);
}
this[ll] = n.pop();
for (let e = 0; e < n.length; e++) {
try {
hl(this, this.mapper(n[e]));
} catch (e) {
return r(e);
}
}
this.overflow = this[ll].length > this.maxLength;
if (this.overflow && !this.skipOverflow) {
r(new Error("maximum buffer reached"));
return;
}
r();
}
function ul(e) {
this[ll] += this[al].end();
if (this[ll]) {
try {
hl(this, this.mapper(this[ll]));
} catch (t) {
return e(t);
}
}
e();
}
function hl(e, t) {
if (t !== undefined) {
e.push(t);
}
}
function dl(e) {
return e;
}
function yl(e, t, r) {
e = e || /\r?\n/;
t = t || dl;
r = r || {};
switch (arguments.length) {
case 1:
if (typeof e === "function") {
t = e;
e = /\r?\n/;
} else if (typeof e === "object" && !(e instanceof RegExp) && !e[Symbol.split]) {
r = e;
e = /\r?\n/;
}
break;
case 2:
if (typeof e === "function") {
r = t;
t = e;
e = /\r?\n/;
} else if (typeof t === "object") {
r = t;
t = dl;
}
}
r = Object.assign({}, r);
r.autoDestroy = true;
r.transform = fl;
r.flush = ul;
r.readableObjectMode = true;
const n = new ol(r);
n[ll] = "";
n[al] = new cl("utf8");
n.matcher = e;
n.mapper = t;
n.maxLength = r.maxLength;
n.skipOverflow = r.skipOverflow || false;
n.overflow = false;
n._destroy = function(e, t) {
this._writableState.errorEmitted = false;
t(e);
};
return n;
}
var ml = yl;
const pl = Symbol.for("pino.metadata");
const gl = ml;
const {Duplex: bl} = z.default;
const {parentPort: vl, workerData: wl} = M.default;
function Sl() {
let e;
let t;
const r = new Promise((r, n) => {
e = r;
t = n;
});
r.resolve = e;
r.reject = t;
return r;
}
var Ol = function e(t, r = {}) {
const n = r.expectPinoConfig === true && wl?.workerData?.pinoWillSendConfig === true;
const i = r.parse === "lines";
const s = typeof r.parseLine === "function" ? r.parseLine : JSON.parse;
const o = r.close || El;
const c = gl(function(e) {
let t;
try {
t = s(e);
} catch (t) {
this.emit("unknown", e, t);
return;
}
if (t === null) {
this.emit("unknown", e, "Null value ignored");
return;
}
if (typeof t !== "object") {
t = {
data: t,
time: Date.now()
};
}
if (c[pl]) {
c.lastTime = t.time;
c.lastLevel = t.level;
c.lastObj = t;
}
if (i) {
return e;
}
return t;
}, {
autoDestroy: true
});
c._destroy = function(e, t) {
const r = o(e, t);
if (r && typeof r.then === "function") {
r.then(t, t);
}
};
if (r.expectPinoConfig === true && wl?.workerData?.pinoWillSendConfig !== true) {
setImmediate(() => {
c.emit("error", new Error("This transport is not compatible with the current version of pino. Please upgrade pino to the latest version."));
});
}
if (r.metadata !== false) {
c[pl] = true;
c.lastTime = 0;
c.lastLevel = 0;
c.lastObj = null;
}
if (n) {
let e = {};
const t = Sl();
vl.on("message", function r(n) {
if (n.code === "PINO_CONFIG") {
e = n.config;
t.resolve();
vl.off("message", r);
}
});
Object.defineProperties(c, {
levels: {
get() {
return e.levels;
}
},
messageKey: {
get() {
return e.messageKey;
}
},
errorKey: {
get() {
return e.errorKey;
}
}
});
return t.then(l);
}
return l();
function l() {
let e = t(c);
if (e && typeof e.catch === "function") {
e.catch(e => {
c.destroy(e);
});
e = null;
} else if (r.enablePipelining && e) {
return bl.from({
writable: c,
readable: e
});
}
return c;
}
};
function El(e, t) {
process.nextTick(t, e);
}
var _l = {
DATE_FORMAT: "yyyy-mm-dd HH:MM:ss.l o",
DATE_FORMAT_SIMPLE: "HH:MM:ss.l",
ERROR_LIKE_KEYS: [ "err", "error" ],
MESSAGE_KEY: "msg",
LEVEL_KEY: "level",
LEVEL_LABEL: "levelLabel",
TIMESTAMP_KEY: "time",
LEVELS: {
default: "USERLVL",
60: "FATAL",
50: "ERROR",
40: "WARN",
30: "INFO",
20: "DEBUG",
10: "TRACE"
},
LEVEL_NAMES: {
fatal: 60,
error: 50,
warn: 40,
info: 30,
debug: 20,
trace: 10
},
LOGGER_KEYS: [ "pid", "hostname", "name", "level", "time", "timestamp", "caller" ]
};
var Ll = kl;
const {LEVELS: jl, LEVEL_NAMES: xl} = _l;
function kl(e, t, r) {
const n = e ? t || jl : Object.assign({}, jl, t);
const i = e ? r || xl : Object.assign({}, xl, r);
return function(e) {
let t = "default";
if (Number.isInteger(+e)) {
t = Object.prototype.hasOwnProperty.call(n, e) ? e : t;
} else {
t = Object.prototype.hasOwnProperty.call(i, e.toLowerCase()) ? i[e.toLowerCase()] : t;
}
return [ n[t], t ];
};
}
const Al = e => e;
const Tl = {
default: Al,
60: Al,
50: Al,
40: Al,
30: Al,
20: Al,
10: Al,
message: Al,
greyMessage: Al,
property: Al
};
const {createColors: Cl} = ko;
const Bl = Ll;
const Dl = Cl({
useColor: true
});
const {white: $l, bgRed: Ml, red: Pl, yellow: Nl, green: Fl, blue: Il, gray: Rl, cyan: Kl, magenta: zl} = Dl;
const Wl = {
default: $l,
60: Ml,
50: Pl,
40: Nl,
30: Fl,
20: Il,
10: Rl,
message: Kl,
greyMessage: Rl,
property: zl
};
function ql(e) {
return e.reduce(function(e, [t, r]) {
e[t] = typeof Dl[r] === "function" ? Dl[r] : $l;
return e;
}, {
default: $l,
message: Kl,
greyMessage: Rl,
property: zl
});
}
function Gl(e) {
return function(t, r, {customLevels: n, customLevelNames: i} = {}) {
const [s, o] = Bl(e, n, i)(t);
return Object.prototype.hasOwnProperty.call(r, o) ? r[o](s) : r.default(s);
};
}
function Vl(e) {
const t = Gl(e);
const r = function(e, r) {
return t(e, Tl, r);
};
r.message = Tl.message;
r.greyMessage = Tl.greyMessage;
r.property = Tl.property;
r.colors = Cl({
useColor: false
});
return r;
}
function Ul(e) {
const t = Gl(e);
const r = function(e, r) {
return t(e, Wl, r);
};
r.message = Wl.message;
r.property = Wl.property;
r.greyMessage = Wl.greyMessage;
r.colors = Dl;
return r;
}
function Jl(e, t) {
const r = ql(e);
const n = t ? r : Object.assign({}, Wl, r);
const i = Gl(t);
const s = function(e, t) {
return i(e, n, t);
};
s.colors = Dl;
s.message = s.message || n.message;
s.property = s.property || n.property;
s.greyMessage = s.greyMessage || n.greyMessage;
return s;
}
var Hl = function e(t = false, r, n) {
if (t && r !== undefined) {
return Jl(r, n);
} else if (t) {
return Ul(n);
}
return Vl(n);
};
var Yl = function e() {};
var Xl = ta;
const {isMainThread: Zl} = q.default;
const Ql = Tr;
const ea = Yl;
function ta(e) {
const t = new Ql(e);
t.on("error", r);
if (!e.sync && Zl) {
ra(t);
}
return t;
function r(e) {
if (e.code === "EPIPE") {
t.write = ea;
t.end = ea;
t.flushSync = ea;
t.destroy = ea;
return;
}
t.removeListener("error", r);
}
}
function ra(e) {
if (p.commonjsGlobal.WeakRef && p.commonjsGlobal.WeakMap && p.commonjsGlobal.FinalizationRegistry) {
const t = Gr;
t.register(e, na);
e.on("close", function() {
t.unregister(e);
});
}
}
function na(e, t) {
if (e.destroyed) {
return;
}
if (t === "beforeExit") {
e.flush();
e.on("drain", function() {
e.end();
});
} else {
e.flushSync();
}
}
var ia = sa;
function sa(e) {
return e instanceof Date && !Number.isNaN(e.getTime());
}
var oa = la;
const ca = ia;
function la(e) {
let t = new Date(e);
if (ca(t)) {
return t;
}
t = new Date(+e);
return t;
}
var aa = fa;
function fa(e) {
const t = [];
let r = false;
let n = "";
for (let i = 0; i < e.length; i++) {
const s = e.charAt(i);
if (s === "\\") {
r = true;
continue;
}
if (r) {
r = false;
n += s;
continue;
}
if (s === ".") {
t.push(n);
n = "";
continue;
}
n += s;
}
if (n.length) {
t.push(n);
}
return t;
}
var ua = da;
const ha = aa;
function da(e, t) {
const r = Array.isArray(t) ? t : ha(t);
for (const t of r) {
if (!Object.prototype.hasOwnProperty.call(e, t)) {
return;
}
e = e[t];
}
return e;
}
var ya = ga;
const ma = ua;
const pa = aa;
function ga(e, t) {
const r = pa(t);
const n = r.pop();
e = ma(e, r);
if (e !== null && typeof e === "object" && Object.prototype.hasOwnProperty.call(e, n)) {
delete e[n];
}
}
var ba = {};
Object.defineProperty(ba, "__esModule", {
value: true
});
var va = Function.prototype.toString;
var wa = Object.create;
var Sa = Object.prototype.toString;
var Oa = function() {
function e() {
this._keys = [];
this._values = [];
}
e.prototype.has = function(e) {
return !!~this._keys.indexOf(e);
};
e.prototype.get = function(e) {
return this._values[this._keys.indexOf(e)];
};
e.prototype.set = function(e, t) {
this._keys.push(e);
this._values.push(t);
};
return e;
}();
function Ea() {
return new Oa;
}
function _a() {
return new WeakMap;
}
var La = typeof WeakMap !== "undefined" ? _a : Ea;
function ja(e) {
if (!e) {
return wa(null);
}
var t = e.constructor;
if (t === Object) {
return e === Object.prototype ? {} : wa(e);
}
if (t && ~va.call(t).indexOf("[native code]")) {
try {
return new t;
} catch (e) {}
}
return wa(e);
}
function xa(e) {
var t = "";
if (e.global) {
t += "g";
}
if (e.ignoreCase) {
t += "i";
}
if (e.multiline) {
t += "m";
}
if (e.unicode) {
t += "u";
}
if (e.sticky) {
t += "y";
}
return t;
}
function ka(e) {
return e.flags;
}
var Aa = /test/g.flags === "g" ? ka : xa;
function Ta(e) {
var t = Sa.call(e);
return t.substring(8, t.length - 1);
}
function Ca(e) {
return e[Symbol.toStringTag] || Ta(e);
}
var Ba = typeof Symbol !== "undefined" ? Ca : Ta;
var Da = Object.defineProperty, $a = Object.getOwnPropertyDescriptor, Ma = Object.getOwnPropertyNames, Pa = Object.getOwnPropertySymbols;
var Na = Object.prototype, Fa = Na.hasOwnProperty, Ia = Na.propertyIsEnumerable;
var Ra = typeof Pa === "function";
function Ka(e) {
return Ma(e).concat(Pa(e));
}
var za = Ra ? Ka : Ma;
function Wa(e, t, r) {
var n = za(e);
for (var i = 0, s = n.length, o = void 0, c = void 0; i < s; ++i) {
o = n[i];
if (o === "callee" || o === "caller") {
continue;
}
c = $a(e, o);
if (!c) {
t[o] = r.copier(e[o], r);
continue;
}
if (!c.get && !c.set) {
c.value = r.copier(c.value, r);
}
try {
Da(t, o, c);
} catch (e) {
t[o] = c.value;
}
}
return t;
}
function qa(e, t) {
var r = new t.Constructor;
t.cache.set(e, r);
for (var n = 0, i = e.length; n < i; ++n) {
r[n] = t.copier(e[n], t);
}
return r;
}
function Ga(e, t) {
var r = new t.Constructor;
t.cache.set(e, r);
return Wa(e, r, t);
}
function Va(e, t) {
return e.slice(0);
}
function Ua(e, t) {
return e.slice(0, e.size, e.type);
}
function Ja(e, t) {
return new t.Constructor(Va(e.buffer));
}
function Ha(e, t) {
return new t.Constructor(e.getTime());
}
function Ya(e, t) {
var r = new t.Constructor;
t.cache.set(e, r);
e.forEach(function(e, n) {
r.set(n, t.copier(e, t));
});
return r;
}
function Xa(e, t) {
return Wa(e, Ya(e, t), t);
}
function Za(e, t) {
var r = ja(t.prototype);
t.cache.set(e, r);
for (var n in e) {
if (Fa.call(e, n)) {
r[n] = t.copier(e[n], t);
}
}
return r;
}
function Qa(e, t) {
var r = ja(t.prototype);
t.cache.set(e, r);
for (var n in e) {
if (Fa.call(e, n)) {
r[n] = t.copier(e[n], t);
}
}
var i = Pa(e);
for (var s = 0, o = i.length, c = void 0; s < o; ++s) {
c = i[s];
if (Ia.call(e, c)) {
r[c] = t.copier(e[c], t);
}
}
return r;
}
var ef = Ra ? Qa : Za;
function tf(e, t) {
var r = ja(t.prototype);
t.cache.set(e, r);
return Wa(e, r, t);
}
function rf(e, t) {
return new t.Constructor(e.valueOf());
}
function nf(e, t) {
var r = new t.Constructor(e.source, Aa(e));
r.lastIndex = e.lastIndex;
return r;
}
function sf(e, t) {
return e;
}
function of(e, t) {
var r = new t.Constructor;
t.cache.set(e, r);
e.forEach(function(e) {
r.add(t.copier(e, t));
});
return r;
}
function cf(e, t) {
return Wa(e, of(e, t), t);
}
var lf = Array.isArray;
var af = Object.assign;
var ff = Object.getPrototypeOf || function(e) {
return e.__proto__;
};
var uf = {
array: qa,
arrayBuffer: Va,
blob: Ua,
dataView: Ja,
date: Ha,
error: sf,
map: Ya,
object: ef,
regExp: nf,
set: of
};
var hf = af({}, uf, {
array: Ga,
map: Xa,
object: tf,
set: cf
});
function df(e) {
return {
Arguments: e.object,
Array: e.array,
ArrayBuffer: e.arrayBuffer,
Blob: e.blob,
Boolean: rf,
DataView: e.dataView,
Date: e.date,
Error: e.error,
Float32Array: e.arrayBuffer,
Float64Array: e.arrayBuffer,
Int8Array: e.arrayBuffer,
Int16Array: e.arrayBuffer,
Int32Array: e.arrayBuffer,
Map: e.map,
Number: rf,
Object: e.object,
Promise: sf,
RegExp: e.regExp,
Set: e.set,
String: rf,
WeakMap: sf,
WeakSet: sf,
Uint8Array: e.arrayBuffer,
Uint8ClampedArray: e.arrayBuffer,
Uint16Array: e.arrayBuffer,
Uint32Array: e.arrayBuffer,
Uint64Array: e.arrayBuffer
};
}
function yf(e) {
var t = af({}, uf, e);
var r = df(t);
var n = r.Array, i = r.Object;
function s(e, t) {
t.prototype = t.Constructor = undefined;
if (!e || typeof e !== "object") {
return e;
}
if (t.cache.has(e)) {
return t.cache.get(e);
}
t.prototype = ff(e);
t.Constructor = t.prototype && t.prototype.constructor;
if (!t.Constructor || t.Constructor === Object) {
return i(e, t);
}
if (lf(e)) {
return n(e, t);
}
var s = r[Ba(e)];
if (s) {
return s(e, t);
}
return typeof e.then === "function" ? e : i(e, t);
}
return function e(t) {
return s(t, {
Constructor: undefined,
cache: La(),
copier: s,
prototype: undefined
});
};
}
function mf(e) {
return yf(af({}, hf, e));
}
var pf = mf({});
var gf = yf({});
ba.copyStrict = pf;
ba.createCopier = yf;
ba.createStrictCopier = mf;
ba.default = gf;
var bf = Of;
const {createCopier: vf} = ba;
const wf = vf({});
const Sf = ya;
function Of({log: e, context: t}) {
const {ignoreKeys: r, includeKeys: n} = t;
const i = wf(e);
if (n) {
const e = {};
n.forEach(t => {
e[t] = i[t];
});
return e;
}
r.forEach(e => {
Sf(i, e);
});
return i;
}
var Ef = {
exports: {}
};
Ef.exports;
(function(e, t) {
function r(e) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
r = function e(t) {
return typeof t;
};
} else {
r = function e(t) {
return t && typeof Symbol === "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
};
}
return r(e);
}
(function(n) {
var i = arguments;
var s = function() {
var e = /d{1,4}|D{3,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|W{1,2}|[LlopSZN]|"[^"]*"|'[^']*'/g;
var t = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g;
var r = /[^-+\dA-Z]/g;
return function(n, u, h, d) {
if (i.length === 1 && f(n) === "string" && !/\d/.test(n)) {
u = n;
n = undefined;
}
n = n || n === 0 ? n : new Date;
if (!(n instanceof Date)) {
n = new Date(n);
}
if (isNaN(n)) {
throw TypeError("Invalid date");
}
u = String(s.masks[u] || u || s.masks["default"]);
var y = u.slice(0, 4);
if (y === "UTC:" || y === "GMT:") {
u = u.slice(4);
h = true;
if (y === "GMT:") {
d = true;
}
}
var m = function e() {
return h ? "getUTC" : "get";
};
var p = function e() {
return n[m() + "Date"]();
};
var g = function e() {
return n[m() + "Day"]();
};
var b = function e() {
return n[m() + "Month"]();
};
var v = function e() {
return n[m() + "FullYear"]();
};
var w = function e() {
return n[m() + "Hours"]();
};
var S = function e() {
return n[m() + "Minutes"]();
};
var O = function e() {
return n[m() + "Seconds"]();
};
var E = function e() {
return n[m() + "Milliseconds"]();
};
var _ = function e() {
return h ? 0 : n.getTimezoneOffset();
};
var L = function e() {
return l(n);
};
var j = function e() {
return a(n);
};
var x = {
d: function e() {
return p();
},
dd: function e() {
return o(p());
},
ddd: function e() {
return s.i18n.dayNames[g()];
},
DDD: function e() {
return c({
y: v(),
m: b(),
d: p(),
_: m(),
dayName: s.i18n.dayNames[g()],
short: true
});
},
dddd: function e() {
return s.i18n.dayNames[g() + 7];
},
DDDD: function e() {
return c({
y: v(),
m: b(),
d: p(),
_: m(),
dayName: s.i18n.dayNames[g() + 7]
});
},
m: function e() {
return b() + 1;
},
mm: function e() {
return o(b() + 1);
},
mmm: function e() {
return s.i18n.monthNames[b()];
},
mmmm: function e() {
return s.i18n.monthNames[b() + 12];
},
yy: function e() {
return String(v()).slice(2);
},
yyyy: function e() {
return o(v(), 4);
},
h: function e() {
return w() % 12 || 12;
},
hh: function e() {
return o(w() % 12 || 12);
},
H: function e() {
return w();
},
HH: function e() {
return o(w());
},
M: function e() {
return S();
},
MM: function e() {
return o(S());
},
s: function e() {
return O();
},
ss: function e() {
return o(O());
},
l: function e() {
return o(E(), 3);
},
L: function e() {
return o(Math.floor(E() / 10));
},
t: function e() {
return w() < 12 ? s.i18n.timeNames[0] : s.i18n.timeNames[1];
},
tt: function e() {
return w() < 12 ? s.i18n.timeNames[2] : s.i18n.timeNames[3];
},
T: function e() {
return w() < 12 ? s.i18n.timeNames[4] : s.i18n.timeNames[5];
},
TT: function e() {
return w() < 12 ? s.i18n.timeNames[6] : s.i18n.timeNames[7];
},
Z: function e() {
return d ? "GMT" : h ? "UTC" : (String(n).match(t) || [ "" ]).pop().replace(r, "").replace(/GMT\+0000/g, "UTC");
},
o: function e() {
return (_() > 0 ? "-" : "+") + o(Math.floor(Math.abs(_()) / 60) * 100 + Math.abs(_()) % 60, 4);
},
p: function e() {
return (_() > 0 ? "-" : "+") + o(Math.floor(Math.abs(_()) / 60), 2) + ":" + o(Math.floor(Math.abs(_()) % 60), 2);
},
S: function e() {
return [ "th", "st", "nd", "rd" ][p() % 10 > 3 ? 0 : (p() % 100 - p() % 10 != 10) * p() % 10];
},
W: function e() {
return L();
},
WW: function e() {
return o(L());
},
N: function e() {
return j();
}
};
return u.replace(e, function(e) {
if (e in x) {
return x[e]();
}
return e.slice(1, e.length - 1);
});
};
}();
s.masks = {
default: "ddd mmm dd yyyy HH:MM:ss",
shortDate: "m/d/yy",
paddedShortDate: "mm/dd/yyyy",
mediumDate: "mmm d, yyyy",
longDate: "mmmm d, yyyy",
fullDate: "dddd, mmmm d, yyyy",
shortTime: "h:MM TT",
mediumTime: "h:MM:ss TT",
longTime: "h:MM:ss TT Z",
isoDate: "yyyy-mm-dd",
isoTime: "HH:MM:ss",
isoDateTime: "yyyy-mm-dd'T'HH:MM:sso",
isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'",
expiresHeaderFormat: "ddd, dd mmm yyyy HH:MM:ss Z"
};
s.i18n = {
dayNames: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
monthNames: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ],
timeNames: [ "a", "p", "am", "pm", "A", "P", "AM", "PM" ]
};
var o = function e(t, r) {
t = String(t);
r = r || 2;
while (t.length < r) {
t = "0" + t;
}
return t;
};
var c = function e(t) {
var r = t.y, n = t.m, i = t.d, s = t._, o = t.dayName, c = t["short"], l = c === void 0 ? false : c;
var a = new Date;
var f = new Date;
f.setDate(f[s + "Date"]() - 1);
var u = new Date;
u.setDate(u[s + "Date"]() + 1);
var h = function e() {
return a[s + "Date"]();
};
var d = function e() {
return a[s + "Month"]();
};
var y = function e() {
return a[s + "FullYear"]();
};
var m = function e() {
return f[s + "Date"]();
};
var p = function e() {
return f[s + "Month"]();
};
var g = function e() {
return f[s + "FullYear"]();
};
var b = function e() {
return u[s + "Date"]();
};
var v = function e() {
return u[s + "Month"]();
};
var w = function e() {
return u[s + "FullYear"]();
};
if (y() === r && d() === n && h() === i) {
return l ? "Tdy" : "Today";
} else if (g() === r && p() === n && m() === i) {
return l ? "Ysd" : "Yesterday";
} else if (w() === r && v() === n && b() === i) {
return l ? "Tmw" : "Tomorrow";
}
return o;
};
var l = function e(t) {
var r = new Date(t.getFullYear(), t.getMonth(), t.getDate());
r.setDate(r.getDate() - (r.getDay() + 6) % 7 + 3);
var n = new Date(r.getFullYear(), 0, 4);
n.setDate(n.getDate() - (n.getDay() + 6) % 7 + 3);
var i = r.getTimezoneOffset() - n.getTimezoneOffset();
r.setHours(r.getHours() - i);
var s = (r - n) / (864e5 * 7);
return 1 + Math.floor(s);
};
var a = function e(t) {
var r = t.getDay();
if (r === 0) {
r = 7;
}
return r;
};
var f = function e(t) {
if (t === null) {
return "null";
}
if (t === undefined) {
return "undefined";
}
if (r(t) !== "object") {
return r(t);
}
if (Array.isArray(t)) {
return "array";
}
return {}.toString.call(t).slice(8, -1).toLowerCase();
};
if (r(t) === "object") {
e.exports = s;
} else {
n.dateFormat = s;
}
})(void 0);
})(Ef, Ef.exports);
var _f = Ef.exports;
var Lf = Cf;
const {DATE_FORMAT: jf, DATE_FORMAT_SIMPLE: xf} = _l;
const kf = _f;
const Af = oa;
const Tf = ia;
function Cf(e, t = false) {
if (t === false) {
return e;
}
const r = Af(e);
if (!Tf(r)) {
return e;
}
if (t === true) {
return kf(r, xf);
}
const n = t.toUpperCase();
if (n === "SYS:STANDARD") {
return kf(r, jf);
}
const i = n.substr(0, 4);
if (i === "SYS:" || i === "UTC:") {
if (i === "UTC:") {
return kf(r, t);
}
return kf(r, t.slice(4));
}
return kf(r, `UTC:${t}`);
}
var Bf = Df;
function Df(e) {
if (!e) return {};
if (typeof e === "string") {
return e.split(",").reduce((e, t, r) => {
const [n, i = r] = t.split(":");
e[n.toLowerCase()] = i;
return e;
}, {});
} else if (Object.prototype.toString.call(e) === "[object Object]") {
return Object.keys(e).reduce((t, r) => {
t[r.toLowerCase()] = e[r];
return t;
}, {});
} else {
return {};
}
}
var $f = Mf;
function Mf(e) {
if (!e) return {};
if (typeof e === "string") {
return e.split(",").reduce((e, t, r) => {
const [n, i = r] = t.split(":");
e[i] = n.toUpperCase();
return e;
}, {
default: "USERLVL"
});
} else if (Object.prototype.toString.call(e) === "[object Object]") {
return Object.keys(e).reduce((t, r) => {
t[e[r]] = r.toUpperCase();
return t;
}, {
default: "USERLVL"
});
} else {
return {};
}
}
var Pf = Ff;
const Nf = ua;
function Ff(e, t) {
e = e.replace(/{if (.*?)}(.*?){end}/g, r);
e = e.replace(/{if (.*?)}/g, "");
e = e.replace(/{end}/g, "");
return e.replace(/\s+/g, " ").trim();
function r(e, r, n) {
const i = Nf(t, r);
if (i && n.includes(r)) {
return n.replace(new RegExp("{" + r + "}", "g"), i);
} else {
return "";
}
}
}
var If = Rf;
function Rf(e) {
return Object.prototype.toString.apply(e) === "[object Object]";
}
var Kf = zf;
function zf({input: e, ident: t = " ", eol: r = "\n"}) {
const n = e.split(/\r?\n/);
for (let e = 1; e < n.length; e += 1) {
n[e] = t + n[e];
}
return n.join(r);
}
var Wf = Hf;
const {LEVEL_NAMES: qf} = _l;
const Gf = Hl;
const Vf = $f;
const Uf = Bf;
const Jf = Ll;
function Hf(e) {
const t = e.crlf ? "\r\n" : "\n";
const r = " ";
const {customPrettifiers: n, errorLikeObjectKeys: i, hideObject: s, levelFirst: o, levelKey: c, levelLabel: l, messageFormat: a, messageKey: f, minimumLevel: u, singleLine: h, timestampKey: d, translateTime: y} = e;
const m = e.errorProps.split(",");
const p = typeof e.useOnlyCustomProps === "boolean" ? e.useOnlyCustomProps : e.useOnlyCustomProps === "true";
const g = Vf(e.customLevels);
const b = Uf(e.customLevels);
const v = Jf(p, g, b);
let w;
if (e.customColors) {
if (typeof e.customColors === "string") {
w = e.customColors.split(",").reduce((t, r) => {
const [n, i] = r.split(":");
const s = p ? e.customLevels : b[n] !== undefined;
const o = s ? b[n] : qf[n];
const c = o !== undefined ? o : n;
t.push([ c, i ]);
return t;
}, []);
} else if (typeof e.customColors === "object") {
w = Object.keys(e.customColors).reduce((t, r) => {
const [n, i] = [ r, e.customColors[r] ];
const s = p ? e.customLevels : b[n] !== undefined;
const o = s ? b[n] : qf[n];
const c = o !== undefined ? o : n;
t.push([ c, i ]);
return t;
}, []);
} else {
throw new Error("options.customColors must be of type string or object.");
}
}
const S = {
customLevels: g,
customLevelNames: b
};
if (p === true && !e.customLevels) {
S.customLevels = undefined;
S.customLevelNames = undefined;
}
const O = e.include !== undefined ? new Set(e.include.split(",")) : undefined;
const E = !O && e.ignore ? new Set(e.ignore.split(",")) : undefined;
const _ = Gf(e.colorize, w, p);
const L = e.colorizeObjects ? _ : Gf(false, [], false);
return {
EOL: t,
IDENT: r,
colorizer: _,
customColors: w,
customLevelNames: b,
customLevels: g,
customPrettifiers: n,
customProperties: S,
errorLikeObjectKeys: i,
errorProps: m,
getLevelLabelData: v,
hideObject: s,
ignoreKeys: E,
includeKeys: O,
levelFirst: o,
levelKey: c,
levelLabel: l,
messageFormat: a,
messageKey: f,
minimumLevel: u,
objectColorizer: L,
singleLine: h,
timestampKey: d,
translateTime: y,
useOnlyCustomProps: p
};
}
var Yf = ru;
ru.default = ru;
ru.stable = ou;
ru.stableStringify = ou;
var Xf = "[...]";
var Zf = "[Circular]";
var Qf = [];
var eu = [];
function tu() {
return {
depthLimit: Number.MAX_SAFE_INTEGER,
edgesLimit: Number.MAX_SAFE_INTEGER
};
}
function ru(e, t, r, n) {
if (typeof n === "undefined") {
n = tu();
}
iu(e, "", 0, [], undefined, 0, n);
var i;
try {
if (eu.length === 0) {
i = JSON.stringify(e, t, r);
} else {
i = JSON.stringify(e, lu(t), r);
}
} catch (e) {
return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
} finally {
while (Qf.length !== 0) {
var s = Qf.pop();
if (s.length === 4) {
Object.defineProperty(s[0], s[1], s[3]);
} else {
s[0][s[1]] = s[2];
}
}
}
return i;
}
function nu(e, t, r, n) {
var i = Object.getOwnPropertyDescriptor(n, r);
if (i.get !== undefined) {
if (i.configurable) {
Object.defineProperty(n, r, {
value: e
});
Qf.push([ n, r, t, i ]);
} else {
eu.push([ t, r, e ]);
}
} else {
n[r] = e;
Qf.push([ n, r, t ]);
}
}
function iu(e, t, r, n, i, s, o) {
s += 1;
var c;
if (typeof e === "object" && e !== null) {
for (c = 0; c < n.length; c++) {
if (n[c] === e) {
nu(Zf, e, t, i);
return;
}
}
if (typeof o.depthLimit !== "undefined" && s > o.depthLimit) {
nu(Xf, e, t, i);
return;
}
if (typeof o.edgesLimit !== "undefined" && r + 1 > o.edgesLimit) {
nu(Xf, e, t, i);
return;
}
n.push(e);
if (Array.isArray(e)) {
for (c = 0; c < e.length; c++) {
iu(e[c], c, c, n, e, s, o);
}
} else {
var l = Object.keys(e);
for (c = 0; c < l.length; c++) {
var a = l[c];
iu(e[a], a, c, n, e, s, o);
}
}
n.pop();
}
}
function su(e, t) {
if (e < t) {
return -1;
}
if (e > t) {
return 1;
}
return 0;
}
function ou(e, t, r, n) {
if (typeof n === "undefined") {
n = tu();
}
var i = cu(e, "", 0, [], undefined, 0, n) || e;
var s;
try {
if (eu.length === 0) {
s = JSON.stringify(i, t, r);
} else {
s = JSON.stringify(i, lu(t), r);
}
} catch (e) {
return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
} finally {
while (Qf.length !== 0) {
var o = Qf.pop();
if (o.length === 4) {
Object.defineProperty(o[0], o[1], o[3]);
} else {
o[0][o[1]] = o[2];
}
}
}
return s;
}
function cu(e, t, r, n, i, s, o) {
s += 1;
var c;
if (typeof e === "object" && e !== null) {
for (c = 0; c < n.length; c++) {
if (n[c] === e) {
nu(Zf, e, t, i);
return;
}
}
try {
if (typeof e.toJSON === "function") {
return;
}
} catch (e) {
return;
}
if (typeof o.depthLimit !== "undefined" && s > o.depthLimit) {
nu(Xf, e, t, i);
return;
}
if (typeof o.edgesLimit !== "undefined" && r + 1 > o.edgesLimit) {
nu(Xf, e, t, i);
return;
}
n.push(e);
if (Array.isArray(e)) {
for (c = 0; c < e.length; c++) {
cu(e[c], c, c, n, e, s, o);
}
} else {
var l = {};
var a = Object.keys(e).sort(su);
for (c = 0; c < a.length; c++) {
var f = a[c];
cu(e[f], f, c, n, e, s, o);
l[f] = e[f];
}
if (typeof i !== "undefined") {
Qf.push([ i, t, e ]);
i[t] = l;
} else {
return l;
}
}
n.pop();
}
}
function lu(e) {
e = typeof e !== "undefined" ? e : function(e, t) {
return t;
};
return function(t, r) {
if (eu.length > 0) {
for (var n = 0; n < eu.length; n++) {
var i = eu[n];
if (i[1] === t && i[0] === r) {
r = i[2];
eu.splice(n, 1);
break;
}
}
}
return e.call(this, t, r);
};
}
var au = uu;
const fu = Kf;
function uu({keyName: e, lines: t, eol: r, ident: n}) {
let i = "";
const s = fu({
input: t,
ident: n,
eol: r
});
const o = `${n}${e}: ${s}${r}`.split(r);
for (let e = 0; e < o.length; e += 1) {
if (e !== 0) i += r;
const t = o[e];
if (/^\s*"stack"/.test(t)) {
const e = /^(\s*"stack":)\s*(".*"),?$/.exec(t);
if (e && e.length === 3) {
const n = /^\s*/.exec(t)[0].length + 4;
const s = " ".repeat(n);
const o = e[2];
i += e[1] + r + s + JSON.parse(o).replace(/\n/g, r + s);
} else {
i += t;
}
} else {
i += t;
}
}
return i;
}
var hu = gu;
const {LOGGER_KEYS: du} = _l;
const yu = Yf;
const mu = Kf;
const pu = au;
function gu({log: e, excludeLoggerKeys: t = true, skipKeys: r = [], context: n}) {
const {EOL: i, IDENT: s, customPrettifiers: o, errorLikeObjectKeys: c, objectColorizer: l, singleLine: a, colorizer: f} = n;
const u = [].concat(r);
if (t === true) Array.prototype.push.apply(u, du);
let h = "";
const {plain: d, errors: y} = Object.entries(e).reduce(({plain: t, errors: r}, [n, i]) => {
if (u.includes(n) === false) {
const s = typeof o[n] === "function" ? o[n](i, n, e, {
colors: f.colors
}) : i;
if (c.includes(n)) {
r[n] = s;
} else {
t[n] = s;
}
}
return {
plain: t,
errors: r
};
}, {
plain: {},
errors: {}
});
if (a) {
if (Object.keys(d).length > 0) {
h += l.greyMessage(yu(d));
}
h += i;
h = h.replace(/\\\\/gi, "\\");
} else {
Object.entries(d).forEach(([e, t]) => {
let r = typeof o[e] === "function" ? t : yu(t, null, 2);
if (r === undefined) return;
r = r.replace(/\\\\/gi, "\\");
const n = mu({
input: r,
ident: s,
eol: i
});
h += `${s}${l.property(e)}:${n.startsWith(i) ? "" : " "}${n}${i}`;
});
}
Object.entries(y).forEach(([e, t]) => {
const r = typeof o[e] === "function" ? t : yu(t, null, 2);
if (r === undefined) return;
h += pu({
keyName: e,
lines: r,
eol: i,
ident: s
});
});
return h;
}
var bu = Eu;
const {LOGGER_KEYS: vu} = _l;
const wu = If;
const Su = Kf;
const Ou = hu;
function Eu({log: e, context: t}) {
const {EOL: r, IDENT: n, errorProps: i, messageKey: s} = t;
const o = e.stack;
const c = Su({
input: o,
ident: n,
eol: r
});
let l = `${n}${c}${r}`;
if (i.length > 0) {
const o = vu.concat(s, "type", "stack");
let c;
if (i[0] === "*") {
c = Object.keys(e).filter(e => o.includes(e) === false);
} else {
c = i.filter(e => o.includes(e) === false);
}
for (let i = 0; i < c.length; i += 1) {
const s = c[i];
if (s in e === false) continue;
if (wu(e[s])) {
const i = Ou({
log: e[s],
excludeLoggerKeys: false,
context: {
...t,
IDENT: n + n
}
});
l = `${l}${n}${s}: {${r}${i}${n}}${r}`;
continue;
}
l = `${l}${n}${s}: ${e[s]}${r}`;
}
}
return l;
}
var _u = ju;
const Lu = ua;
function ju({log: e, context: t}) {
const {colorizer: r, customLevels: n, customLevelNames: i, levelKey: s, getLevelLabelData: o} = t;
const c = t.customPrettifiers?.level;
const l = Lu(e, s);
if (l === undefined) return undefined;
const a = r(l, {
customLevels: n,
customLevelNames: i
});
if (c) {
const [t] = o(l);
return c(l, s, e, {
label: t,
labelColorized: a,
colors: r.colors
});
}
return a;
}
var xu = Cu;
const {LEVELS: ku} = _l;
const Au = ua;
const Tu = Pf;
function Cu({log: e, context: t}) {
const {colorizer: r, customLevels: n, levelKey: i, levelLabel: s, messageFormat: o, messageKey: c, useOnlyCustomProps: l} = t;
if (o && typeof o === "string") {
const t = Tu(o, e);
const c = String(t).replace(/{([^{}]+)}/g, function(t, r) {
let o;
if (r === s && (o = Au(e, i)) !== undefined) {
const e = l ? n === undefined : n[o] === undefined;
return e ? ku[o] : n[o];
}
return Au(e, r) || "";
});
return r.message(c);
}
if (o && typeof o === "function") {
const t = o(e, c, s, {
colors: r.colors
});
return r.message(t);
}
if (c in e === false) return undefined;
if (typeof e[c] !== "string" && typeof e[c] !== "number" && typeof e[c] !== "boolean") return undefined;
return r.message(e[c]);
}
var Bu = Du;
function Du({log: e, context: t}) {
const {customPrettifiers: r, colorizer: n} = t;
let i = "";
if (e.name || e.pid || e.hostname) {
i += "(";
if (e.name) {
i += r.name ? r.name(e.name, "name", e, {
colors: n.colors
}) : e.name;
}
if (e.pid) {
const t = r.pid ? r.pid(e.pid, "pid", e, {
colors: n.colors
}) : e.pid;
if (e.name && e.pid) {
i += "/" + t;
} else {
i += t;
}
}
if (e.hostname) {
const t = r.hostname ? r.hostname(e.hostname, "hostname", e, {
colors: n.colors
}) : e.hostname;
i += `${i === "(" ? "on" : " on"} ${t}`;
}
i += ")";
}
if (e.caller) {
const t = r.caller ? r.caller(e.caller, "caller", e, {
colors: n.colors
}) : e.caller;
i += `${i === "" ? "" : " "}<${t}>`;
}
if (i === "") {
return undefined;
} else {
return i;
}
}
var $u = Pu;
const Mu = Lf;
function Pu({log: e, context: t}) {
const {timestampKey: r, translateTime: n} = t;
const i = t.customPrettifiers?.time;
let s = null;
if (r in e) {
s = e[r];
} else if ("timestamp" in e) {
s = e.timestamp;
}
if (s === null) return undefined;
const o = n ? Mu(s, n) : s;
return i ? i(o) : `[${o}]`;
}
var Nu = {
buildSafeSonicBoom: Xl,
createDate: oa,
deleteLogProperty: ya,
filterLog: bf,
formatTime: Lf,
getPropertyValue: ua,
handleCustomLevelsNamesOpts: Bf,
handleCustomLevelsOpts: $f,
interpretConditionals: Pf,
isObject: If,
isValidDate: ia,
joinLinesWithIndentation: Kf,
noop: Yl,
parseFactoryOptions: Wf,
prettifyErrorLog: bu,
prettifyError: au,
prettifyLevel: _u,
prettifyMessage: xu,
prettifyMetadata: Bu,
prettifyObject: hu,
prettifyTime: $u,
splitPropertyKey: aa,
getLevelLabelData: Ll
};
var Fu = {
exports: {}
};
Fu.exports;
const Iu = typeof Buffer !== "undefined";
const Ru = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
const Ku = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
function zu(e, t, r) {
if (r == null) {
if (t !== null && typeof t === "object") {
r = t;
t = undefined;
}
}
if (Iu && Buffer.isBuffer(e)) {
e = e.toString();
}
if (e && e.charCodeAt(0) === 65279) {
e = e.slice(1);
}
const n = JSON.parse(e, t);
if (n === null || typeof n !== "object") {
return n;
}
const i = r && r.protoAction || "error";
const s = r && r.constructorAction || "error";
if (i === "ignore" && s === "ignore") {
return n;
}
if (i !== "ignore" && s !== "ignore") {
if (Ru.test(e) === false && Ku.test(e) === false) {
return n;
}
} else if (i !== "ignore" && s === "ignore") {
if (Ru.test(e) === false) {
return n;
}
} else {
if (Ku.test(e) === false) {
return n;
}
}
return Wu(n, {
protoAction: i,
constructorAction: s,
safe: r && r.safe
});
}
function Wu(e, {protoAction: t = "error", constructorAction: r = "error", safe: n} = {}) {
let i = [ e ];
while (i.length) {
const e = i;
i = [];
for (const s of e) {
if (t !== "ignore" && Object.prototype.hasOwnProperty.call(s, "__proto__")) {
if (n === true) {
return null;
} else if (t === "error") {
throw new SyntaxError("Object contains forbidden prototype property");
}
delete s.__proto__;
}
if (r !== "ignore" && Object.prototype.hasOwnProperty.call(s, "constructor") && s.constructor !== null && typeof s.constructor === "object" && Object.prototype.hasOwnProperty.call(s.constructor, "prototype")) {
if (n === true) {
return null;
} else if (r === "error") {
throw new SyntaxError("Object contains forbidden prototype property");
}
delete s.constructor;
}
for (const e in s) {
const t = s[e];
if (t && typeof t === "object") {
i.push(t);
}
}
}
}
return e;
}
function qu(e, t, r) {
const {stackTraceLimit: n} = Error;
Error.stackTraceLimit = 0;
try {
return zu(e, t, r);
} finally {
Error.stackTraceLimit = n;
}
}
function Gu(e, t) {
const {stackTraceLimit: r} = Error;
Error.stackTraceLimit = 0;
try {
return zu(e, t, {
safe: true
});
} catch {
return undefined;
} finally {
Error.stackTraceLimit = r;
}
}
Fu.exports = qu;
Fu.exports.default = qu;
Fu.exports.parse = qu;
Fu.exports.safeParse = Gu;
Fu.exports.scan = Wu;
var Vu = Fu.exports;
var Uu = ch;
const Ju = Vu;
const Hu = If;
const Yu = bu;
const Xu = _u;
const Zu = xu;
const Qu = Bu;
const eh = hu;
const th = $u;
const rh = bf;
const {LEVELS: nh, LEVEL_KEY: ih, LEVEL_NAMES: sh} = _l;
const oh = e => {
try {
return {
value: Ju.parse(e, {
protoAction: "remove"
})
};
} catch (e) {
return {
err: e
};
}
};
function ch(e) {
let t;
if (!Hu(e)) {
const r = oh(e);
if (r.err || !Hu(r.value)) {
return e + this.EOL;
}
t = r.value;
} else {
t = e;
}
if (this.minimumLevel) {
let e;
if (this.useOnlyCustomProps) {
e = this.customLevels;
} else {
e = this.customLevelNames[this.minimumLevel] !== undefined;
}
let r;
if (e) {
r = this.customLevelNames[this.minimumLevel];
} else {
r = sh[this.minimumLevel];
}
if (!r) {
r = typeof this.minimumLevel === "string" ? sh[this.minimumLevel] : sh[nh[this.minimumLevel].toLowerCase()];
}
const n = t[this.levelKey === undefined ? ih : this.levelKey];
if (n < r) return;
}
const r = Zu({
log: t,
context: this.context
});
if (this.ignoreKeys || this.includeKeys) {
t = rh({
log: t,
context: this.context
});
}
const n = Xu({
log: t,
context: {
...this.context,
...this.context.customProperties
}
});
const i = Qu({
log: t,
context: this.context
});
const s = th({
log: t,
context: this.context
});
let o = "";
if (this.levelFirst && n) {
o = `${n}`;
}
if (s && o === "") {
o = `${s}`;
} else if (s) {
o = `${o} ${s}`;
}
if (!this.levelFirst && n) {
if (o.length > 0) {
o = `${o} ${n}`;
} else {
o = n;
}
}
if (i) {
if (o.length > 0) {
o = `${o} ${i}:`;
} else {
o = i;
}
}
if (o.endsWith(":") === false && o !== "") {
o += ":";
}
if (r !== undefined) {
if (o.length > 0) {
o = `${o} ${r}`;
} else {
o = r;
}
}
if (o.length > 0 && !this.singleLine) {
o += this.EOL;
}
if (t.type === "Error" && typeof t.stack === "string") {
const e = Yu({
log: t,
context: this.context
});
if (this.singleLine) o += this.EOL;
o += e;
} else if (this.hideObject === false) {
const e = [ this.messageKey, this.levelKey, this.timestampKey ].map(e => e.replaceAll(/\\/g, "")).filter(e => typeof t[e] === "string" || typeof t[e] === "number" || typeof t[e] === "boolean");
const r = eh({
log: t,
skipKeys: e,
context: this.context
});
if (this.singleLine && !/^\s$/.test(r)) {
o += " ";
}
o += r;
}
return o;
}
xo.exports;
const {isColorSupported: lh} = ko;
const ah = exports.pump_1;
const {Transform: fh} = K.default;
const uh = Ol;
const hh = Hl;
const {ERROR_LIKE_KEYS: dh, LEVEL_KEY: yh, LEVEL_LABEL: mh, MESSAGE_KEY: ph, TIMESTAMP_KEY: gh} = _l;
const {buildSafeSonicBoom: bh, parseFactoryOptions: vh} = Nu;
const wh = Uu;
const Sh = {
colorize: lh,
colorizeObjects: true,
crlf: false,
customColors: null,
customLevels: null,
customPrettifiers: {},
errorLikeObjectKeys: dh,
errorProps: "",
hideObject: false,
ignore: "hostname",
include: undefined,
levelFirst: false,
levelKey: yh,
levelLabel: mh,
messageFormat: null,
messageKey: ph,
minimumLevel: undefined,
outputStream: process.stdout,
singleLine: false,
timestampKey: gh,
translateTime: true,
useOnlyCustomProps: true
};
function Oh(e) {
const t = vh(Object.assign({}, Sh, e));
return wh.bind({
...t,
context: t
});
}
function Eh(e = {}) {
let t = Oh(e);
let r;
return uh(function(n) {
n.on("message", function r(i) {
if (!i || i.code !== "PINO_CONFIG") return;
Object.assign(e, {
messageKey: i.config.messageKey,
errorLikeObjectKeys: Array.from(new Set([ ...e.errorLikeObjectKeys || dh, i.config.errorKey ])),
customLevels: i.config.levels.values
});
t = Oh(e);
n.off("message", r);
});
const i = new fh({
objectMode: true,
autoDestroy: true,
transform(e, r, n) {
const i = t(e);
n(null, i);
}
});
if (typeof e.destination === "object" && typeof e.destination.write === "function") {
r = e.destination;
} else {
r = bh({
dest: e.destination || 1,
append: e.append,
mkdir: e.mkdir,
sync: e.sync
});
}
n.on("unknown", function(e) {
r.write(e + "\n");
});
ah(n, i, r);
return i;
}, {
parse: "lines",
close(e, t) {
r.on("close", () => {
t(e);
});
}
});
}
xo.exports = Eh;
xo.exports.build = Eh;
xo.exports.PinoPretty = Eh;
xo.exports.prettyFactory = Oh;
xo.exports.colorizerFactory = hh;
xo.exports.isColorSupported = lh;
xo.exports.default = Eh;
var _h = xo.exports;
const Lh = p.getDefaultExportFromCjs(_h);
exports.Logger = class Logger extends t.Component {
#e;
async init() {
this.#e = jo({
level: this.level,
name: v.GetBasicInfo().appName || "Unnamed"
}, Lo(this.destinations.map(e => {
const t = _o(e);
return L.As(L.As(Lh)({
colorize: e === process.stdout ? this.colorize : false,
sync: this.sync,
destination: t
}));
})));
}
error(e, ...t) {
return this.#e.error(e, ...t);
}
warn(e, ...t) {
return this.#e.warn(e, ...t);
}
info(e, ...t) {
return this.#e.info(e, ...t);
}
debug(e, ...t) {
return this.#e.debug(e, ...t);
}
trace(e, ...t) {
return this.#e.trace(e, ...t);
}
};
e.__decorate([ n.Configurable(i.DTO.Boolean().optional().default(true)), e.__metadata("design:type", Boolean) ], exports.Logger.prototype, "pretty", void 0);
e.__decorate([ n.Configurable(i.DTO.String().optional().default("trace")), e.__metadata("design:type", String) ], exports.Logger.prototype, "level", void 0);
e.__decorate([ n.Configurable(i.DTO.Boolean().optional().default(true)), e.__metadata("design:type", Boolean) ], exports.Logger.prototype, "colorize", void 0);
e.__decorate([ n.Configurable(i.DTO.Boolean().optional().default(false)), e.__metadata("design:type", Boolean) ], exports.Logger.prototype, "sync", void 0);
e.__decorate([ n.Configurable(i.DTO.Array(i.DTO.InstanceOf(S.Stream)).optional().default(() => [ process.stdout ])), e.__metadata("design:type", Array) ], exports.Logger.prototype, "destinations", void 0);
exports.Logger = e.__decorate([ r.Singleton() ], exports.Logger);