510 lines
17 KiB
Plaintext
510 lines
17 KiB
Plaintext
import {
|
|
__commonJS
|
|
} from "/_nuxt/node_modules/.cache/vite/client/deps/chunk-V4OQ3NZ2.js?v=e4f18c29";
|
|
|
|
// ../../node_modules/quick-format-unescaped/index.js
|
|
var require_quick_format_unescaped = __commonJS({
|
|
"../../node_modules/quick-format-unescaped/index.js"(exports, module) {
|
|
"use strict";
|
|
function tryStringify(o) {
|
|
try {
|
|
return JSON.stringify(o);
|
|
} catch (e) {
|
|
return '"[Circular]"';
|
|
}
|
|
}
|
|
module.exports = format;
|
|
function format(f, args, opts) {
|
|
var ss = opts && opts.stringify || tryStringify;
|
|
var offset = 1;
|
|
if (typeof f === "object" && f !== null) {
|
|
var len = args.length + offset;
|
|
if (len === 1) return f;
|
|
var objects = new Array(len);
|
|
objects[0] = ss(f);
|
|
for (var index = 1; index < len; index++) {
|
|
objects[index] = ss(args[index]);
|
|
}
|
|
return objects.join(" ");
|
|
}
|
|
if (typeof f !== "string") {
|
|
return f;
|
|
}
|
|
var argLen = args.length;
|
|
if (argLen === 0) return f;
|
|
var str = "";
|
|
var a = 1 - offset;
|
|
var lastPos = -1;
|
|
var flen = f && f.length || 0;
|
|
for (var i = 0; i < flen; ) {
|
|
if (f.charCodeAt(i) === 37 && i + 1 < flen) {
|
|
lastPos = lastPos > -1 ? lastPos : 0;
|
|
switch (f.charCodeAt(i + 1)) {
|
|
case 100:
|
|
// 'd'
|
|
case 102:
|
|
if (a >= argLen)
|
|
break;
|
|
if (args[a] == null) break;
|
|
if (lastPos < i)
|
|
str += f.slice(lastPos, i);
|
|
str += Number(args[a]);
|
|
lastPos = i + 2;
|
|
i++;
|
|
break;
|
|
case 105:
|
|
if (a >= argLen)
|
|
break;
|
|
if (args[a] == null) break;
|
|
if (lastPos < i)
|
|
str += f.slice(lastPos, i);
|
|
str += Math.floor(Number(args[a]));
|
|
lastPos = i + 2;
|
|
i++;
|
|
break;
|
|
case 79:
|
|
// 'O'
|
|
case 111:
|
|
// 'o'
|
|
case 106:
|
|
if (a >= argLen)
|
|
break;
|
|
if (args[a] === void 0) break;
|
|
if (lastPos < i)
|
|
str += f.slice(lastPos, i);
|
|
var type = typeof args[a];
|
|
if (type === "string") {
|
|
str += "'" + args[a] + "'";
|
|
lastPos = i + 2;
|
|
i++;
|
|
break;
|
|
}
|
|
if (type === "function") {
|
|
str += args[a].name || "<anonymous>";
|
|
lastPos = i + 2;
|
|
i++;
|
|
break;
|
|
}
|
|
str += ss(args[a]);
|
|
lastPos = i + 2;
|
|
i++;
|
|
break;
|
|
case 115:
|
|
if (a >= argLen)
|
|
break;
|
|
if (lastPos < i)
|
|
str += f.slice(lastPos, i);
|
|
str += String(args[a]);
|
|
lastPos = i + 2;
|
|
i++;
|
|
break;
|
|
case 37:
|
|
if (lastPos < i)
|
|
str += f.slice(lastPos, i);
|
|
str += "%";
|
|
lastPos = i + 2;
|
|
i++;
|
|
a--;
|
|
break;
|
|
}
|
|
++a;
|
|
}
|
|
++i;
|
|
}
|
|
if (lastPos === -1)
|
|
return f;
|
|
else if (lastPos < flen) {
|
|
str += f.slice(lastPos);
|
|
}
|
|
return str;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/pino/browser.js
|
|
var require_browser = __commonJS({
|
|
"../../node_modules/pino/browser.js"(exports, module) {
|
|
var format = require_quick_format_unescaped();
|
|
module.exports = pino;
|
|
var _console = pfGlobalThisOrFallback().console || {};
|
|
var stdSerializers = {
|
|
mapHttpRequest: mock,
|
|
mapHttpResponse: mock,
|
|
wrapRequestSerializer: passthrough,
|
|
wrapResponseSerializer: passthrough,
|
|
wrapErrorSerializer: passthrough,
|
|
req: mock,
|
|
res: mock,
|
|
err: asErrValue,
|
|
errWithCause: asErrValue
|
|
};
|
|
function levelToValue(level, logger) {
|
|
return level === "silent" ? Infinity : logger.levels.values[level];
|
|
}
|
|
var baseLogFunctionSymbol = Symbol("pino.logFuncs");
|
|
var hierarchySymbol = Symbol("pino.hierarchy");
|
|
var logFallbackMap = {
|
|
error: "log",
|
|
fatal: "error",
|
|
warn: "error",
|
|
info: "log",
|
|
debug: "log",
|
|
trace: "log"
|
|
};
|
|
function appendChildLogger(parentLogger, childLogger) {
|
|
const newEntry = {
|
|
logger: childLogger,
|
|
parent: parentLogger[hierarchySymbol]
|
|
};
|
|
childLogger[hierarchySymbol] = newEntry;
|
|
}
|
|
function setupBaseLogFunctions(logger, levels, proto) {
|
|
const logFunctions = {};
|
|
levels.forEach((level) => {
|
|
logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop;
|
|
});
|
|
logger[baseLogFunctionSymbol] = logFunctions;
|
|
}
|
|
function shouldSerialize(serialize, serializers) {
|
|
if (Array.isArray(serialize)) {
|
|
const hasToFilter = serialize.filter(function(k) {
|
|
return k !== "!stdSerializers.err";
|
|
});
|
|
return hasToFilter;
|
|
} else if (serialize === true) {
|
|
return Object.keys(serializers);
|
|
}
|
|
return false;
|
|
}
|
|
function pino(opts) {
|
|
opts = opts || {};
|
|
opts.browser = opts.browser || {};
|
|
const transmit2 = opts.browser.transmit;
|
|
if (transmit2 && typeof transmit2.send !== "function") {
|
|
throw Error("pino: transmit option must have a send function");
|
|
}
|
|
const proto = opts.browser.write || _console;
|
|
if (opts.browser.write) opts.browser.asObject = true;
|
|
const serializers = opts.serializers || {};
|
|
const serialize = shouldSerialize(opts.browser.serialize, serializers);
|
|
let stdErrSerialize = opts.browser.serialize;
|
|
if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
|
|
const customLevels = Object.keys(opts.customLevels || {});
|
|
const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels);
|
|
if (typeof proto === "function") {
|
|
levels.forEach(function(level2) {
|
|
proto[level2] = proto;
|
|
});
|
|
}
|
|
if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
|
|
const level = opts.level || "info";
|
|
const logger = Object.create(proto);
|
|
if (!logger.log) logger.log = noop;
|
|
setupBaseLogFunctions(logger, levels, proto);
|
|
appendChildLogger({}, logger);
|
|
Object.defineProperty(logger, "levelVal", {
|
|
get: getLevelVal
|
|
});
|
|
Object.defineProperty(logger, "level", {
|
|
get: getLevel,
|
|
set: setLevel
|
|
});
|
|
const setOpts = {
|
|
transmit: transmit2,
|
|
serialize,
|
|
asObject: opts.browser.asObject,
|
|
levels,
|
|
timestamp: getTimeFunction(opts)
|
|
};
|
|
logger.levels = getLevels(opts);
|
|
logger.level = level;
|
|
logger.setMaxListeners = logger.getMaxListeners = logger.emit = logger.addListener = logger.on = logger.prependListener = logger.once = logger.prependOnceListener = logger.removeListener = logger.removeAllListeners = logger.listeners = logger.listenerCount = logger.eventNames = logger.write = logger.flush = noop;
|
|
logger.serializers = serializers;
|
|
logger._serialize = serialize;
|
|
logger._stdErrSerialize = stdErrSerialize;
|
|
logger.child = child;
|
|
if (transmit2) logger._logEvent = createLogEventShape();
|
|
function getLevelVal() {
|
|
return levelToValue(this.level, this);
|
|
}
|
|
function getLevel() {
|
|
return this._level;
|
|
}
|
|
function setLevel(level2) {
|
|
if (level2 !== "silent" && !this.levels.values[level2]) {
|
|
throw Error("unknown level " + level2);
|
|
}
|
|
this._level = level2;
|
|
set(this, setOpts, logger, "error");
|
|
set(this, setOpts, logger, "fatal");
|
|
set(this, setOpts, logger, "warn");
|
|
set(this, setOpts, logger, "info");
|
|
set(this, setOpts, logger, "debug");
|
|
set(this, setOpts, logger, "trace");
|
|
customLevels.forEach((level3) => {
|
|
set(this, setOpts, logger, level3);
|
|
});
|
|
}
|
|
function child(bindings, childOptions) {
|
|
if (!bindings) {
|
|
throw new Error("missing bindings for child Pino");
|
|
}
|
|
childOptions = childOptions || {};
|
|
if (serialize && bindings.serializers) {
|
|
childOptions.serializers = bindings.serializers;
|
|
}
|
|
const childOptionsSerializers = childOptions.serializers;
|
|
if (serialize && childOptionsSerializers) {
|
|
var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
|
|
var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
|
|
delete bindings.serializers;
|
|
applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
|
|
}
|
|
function Child(parent) {
|
|
this._childLevel = (parent._childLevel | 0) + 1;
|
|
this.bindings = bindings;
|
|
if (childSerializers) {
|
|
this.serializers = childSerializers;
|
|
this._serialize = childSerialize;
|
|
}
|
|
if (transmit2) {
|
|
this._logEvent = createLogEventShape(
|
|
[].concat(parent._logEvent.bindings, bindings)
|
|
);
|
|
}
|
|
}
|
|
Child.prototype = this;
|
|
const newLogger = new Child(this);
|
|
appendChildLogger(this, newLogger);
|
|
newLogger.level = this.level;
|
|
return newLogger;
|
|
}
|
|
return logger;
|
|
}
|
|
function getLevels(opts) {
|
|
const customLevels = opts.customLevels || {};
|
|
const values = Object.assign({}, pino.levels.values, customLevels);
|
|
const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels));
|
|
return {
|
|
values,
|
|
labels
|
|
};
|
|
}
|
|
function invertObject(obj) {
|
|
const inverted = {};
|
|
Object.keys(obj).forEach(function(key) {
|
|
inverted[obj[key]] = key;
|
|
});
|
|
return inverted;
|
|
}
|
|
pino.levels = {
|
|
values: {
|
|
fatal: 60,
|
|
error: 50,
|
|
warn: 40,
|
|
info: 30,
|
|
debug: 20,
|
|
trace: 10
|
|
},
|
|
labels: {
|
|
10: "trace",
|
|
20: "debug",
|
|
30: "info",
|
|
40: "warn",
|
|
50: "error",
|
|
60: "fatal"
|
|
}
|
|
};
|
|
pino.stdSerializers = stdSerializers;
|
|
pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
|
|
function getBindingChain(logger) {
|
|
const bindings = [];
|
|
if (logger.bindings) {
|
|
bindings.push(logger.bindings);
|
|
}
|
|
let hierarchy = logger[hierarchySymbol];
|
|
while (hierarchy.parent) {
|
|
hierarchy = hierarchy.parent;
|
|
if (hierarchy.logger.bindings) {
|
|
bindings.push(hierarchy.logger.bindings);
|
|
}
|
|
}
|
|
return bindings.reverse();
|
|
}
|
|
function set(self2, opts, rootLogger, level) {
|
|
self2[level] = levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level];
|
|
if (!opts.transmit && self2[level] === noop) {
|
|
return;
|
|
}
|
|
self2[level] = createWrap(self2, opts, rootLogger, level);
|
|
const bindings = getBindingChain(self2);
|
|
if (bindings.length === 0) {
|
|
return;
|
|
}
|
|
self2[level] = prependBindingsInArguments(bindings, self2[level]);
|
|
}
|
|
function prependBindingsInArguments(bindings, logFunc) {
|
|
return function() {
|
|
return logFunc.apply(this, [...bindings, ...arguments]);
|
|
};
|
|
}
|
|
function createWrap(self2, opts, rootLogger, level) {
|
|
return /* @__PURE__ */ function(write) {
|
|
return function LOG() {
|
|
const ts = opts.timestamp();
|
|
const args = new Array(arguments.length);
|
|
const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
|
|
for (var i = 0; i < args.length; i++) args[i] = arguments[i];
|
|
if (opts.serialize && !opts.asObject) {
|
|
applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
|
|
}
|
|
if (opts.asObject) write.call(proto, asObject(this, level, args, ts));
|
|
else write.apply(proto, args);
|
|
if (opts.transmit) {
|
|
const transmitLevel = opts.transmit.level || self2._level;
|
|
const transmitValue = rootLogger.levels.values[transmitLevel];
|
|
const methodValue = rootLogger.levels.values[level];
|
|
if (methodValue < transmitValue) return;
|
|
transmit(this, {
|
|
ts,
|
|
methodLevel: level,
|
|
methodValue,
|
|
transmitLevel,
|
|
transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level],
|
|
send: opts.transmit.send,
|
|
val: levelToValue(self2._level, rootLogger)
|
|
}, args);
|
|
}
|
|
};
|
|
}(self2[baseLogFunctionSymbol][level]);
|
|
}
|
|
function asObject(logger, level, args, ts) {
|
|
if (logger._serialize) applySerializers(args, logger._serialize, logger.serializers, logger._stdErrSerialize);
|
|
const argsCloned = args.slice();
|
|
let msg = argsCloned[0];
|
|
const o = {};
|
|
if (ts) {
|
|
o.time = ts;
|
|
}
|
|
o.level = logger.levels.values[level];
|
|
let lvl = (logger._childLevel | 0) + 1;
|
|
if (lvl < 1) lvl = 1;
|
|
if (msg !== null && typeof msg === "object") {
|
|
while (lvl-- && typeof argsCloned[0] === "object") {
|
|
Object.assign(o, argsCloned.shift());
|
|
}
|
|
msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
|
|
} else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
|
|
if (msg !== void 0) o.msg = msg;
|
|
return o;
|
|
}
|
|
function applySerializers(args, serialize, serializers, stdErrSerialize) {
|
|
for (const i in args) {
|
|
if (stdErrSerialize && args[i] instanceof Error) {
|
|
args[i] = pino.stdSerializers.err(args[i]);
|
|
} else if (typeof args[i] === "object" && !Array.isArray(args[i])) {
|
|
for (const k in args[i]) {
|
|
if (serialize && serialize.indexOf(k) > -1 && k in serializers) {
|
|
args[i][k] = serializers[k](args[i][k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function transmit(logger, opts, args) {
|
|
const send = opts.send;
|
|
const ts = opts.ts;
|
|
const methodLevel = opts.methodLevel;
|
|
const methodValue = opts.methodValue;
|
|
const val = opts.val;
|
|
const bindings = logger._logEvent.bindings;
|
|
applySerializers(
|
|
args,
|
|
logger._serialize || Object.keys(logger.serializers),
|
|
logger.serializers,
|
|
logger._stdErrSerialize === void 0 ? true : logger._stdErrSerialize
|
|
);
|
|
logger._logEvent.ts = ts;
|
|
logger._logEvent.messages = args.filter(function(arg) {
|
|
return bindings.indexOf(arg) === -1;
|
|
});
|
|
logger._logEvent.level.label = methodLevel;
|
|
logger._logEvent.level.value = methodValue;
|
|
send(methodLevel, logger._logEvent, val);
|
|
logger._logEvent = createLogEventShape(bindings);
|
|
}
|
|
function createLogEventShape(bindings) {
|
|
return {
|
|
ts: 0,
|
|
messages: [],
|
|
bindings: bindings || [],
|
|
level: { label: "", value: 0 }
|
|
};
|
|
}
|
|
function asErrValue(err) {
|
|
const obj = {
|
|
type: err.constructor.name,
|
|
msg: err.message,
|
|
stack: err.stack
|
|
};
|
|
for (const key in err) {
|
|
if (obj[key] === void 0) {
|
|
obj[key] = err[key];
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
function getTimeFunction(opts) {
|
|
if (typeof opts.timestamp === "function") {
|
|
return opts.timestamp;
|
|
}
|
|
if (opts.timestamp === false) {
|
|
return nullTime;
|
|
}
|
|
return epochTime;
|
|
}
|
|
function mock() {
|
|
return {};
|
|
}
|
|
function passthrough(a) {
|
|
return a;
|
|
}
|
|
function noop() {
|
|
}
|
|
function nullTime() {
|
|
return false;
|
|
}
|
|
function epochTime() {
|
|
return Date.now();
|
|
}
|
|
function unixTime() {
|
|
return Math.round(Date.now() / 1e3);
|
|
}
|
|
function isoTime() {
|
|
return new Date(Date.now()).toISOString();
|
|
}
|
|
function pfGlobalThisOrFallback() {
|
|
function defd(o) {
|
|
return typeof o !== "undefined" && o;
|
|
}
|
|
try {
|
|
if (typeof globalThis !== "undefined") return globalThis;
|
|
Object.defineProperty(Object.prototype, "globalThis", {
|
|
get: function() {
|
|
delete Object.prototype.globalThis;
|
|
return this.globalThis = this;
|
|
},
|
|
configurable: true
|
|
});
|
|
return globalThis;
|
|
} catch (e) {
|
|
return defd(self) || defd(window) || defd(this) || {};
|
|
}
|
|
}
|
|
module.exports.default = pino;
|
|
module.exports.pino = pino;
|
|
}
|
|
});
|
|
export default require_browser();
|
|
//# sourceMappingURL=pino.js.map
|