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