@likec4/log 1.17.1 → 1.19.0

package/dist/browser.cjs

@@ -0,0 +1,1938 @@
+'use strict';
+
+const LogLevels = {
+  silent: Number.NEGATIVE_INFINITY,
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  info: 3,
+  success: 3,
+  fail: 3,
+  ready: 3,
+  start: 3,
+  box: 3,
+  debug: 4,
+  trace: 5,
+  verbose: Number.POSITIVE_INFINITY
+};
+const LogTypes = {
+  // Silent
+  silent: {
+    level: -1
+  },
+  // Level 0
+  fatal: {
+    level: LogLevels.fatal
+  },
+  error: {
+    level: LogLevels.error
+  },
+  // Level 1
+  warn: {
+    level: LogLevels.warn
+  },
+  // Level 2
+  log: {
+    level: LogLevels.log
+  },
+  // Level 3
+  info: {
+    level: LogLevels.info
+  },
+  success: {
+    level: LogLevels.success
+  },
+  fail: {
+    level: LogLevels.fail
+  },
+  ready: {
+    level: LogLevels.info
+  },
+  start: {
+    level: LogLevels.info
+  },
+  box: {
+    level: LogLevels.info
+  },
+  // Level 4
+  debug: {
+    level: LogLevels.debug
+  },
+  // Level 5
+  trace: {
+    level: LogLevels.trace
+  },
+  // Verbose
+  verbose: {
+    level: LogLevels.verbose
+  }
+};
+
+function isPlainObject$1(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject$1(defaults)) {
+    return _defu(baseObject, {}, namespace);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject$1(value) && isPlainObject$1(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString());
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, ""), {})
+  );
+}
+const defu = createDefu();
+
+function isPlainObject$2(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isLogObj(arg) {
+  if (!isPlainObject$2(arg)) {
+    return false;
+  }
+  if (!arg.message && !arg.args) {
+    return false;
+  }
+  if (arg.stack) {
+    return false;
+  }
+  return true;
+}
+
+let paused = false;
+const queue = [];
+class Consola {
+  options;
+  _lastLog;
+  _mockFn;
+  /**
+   * Creates an instance of Consola with specified options or defaults.
+   *
+   * @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
+   */
+  constructor(options = {}) {
+    const types = options.types || LogTypes;
+    this.options = defu(
+      {
+        ...options,
+        defaults: { ...options.defaults },
+        level: _normalizeLogLevel(options.level, types),
+        reporters: [...options.reporters || []]
+      },
+      {
+        types: LogTypes,
+        throttle: 1e3,
+        throttleMin: 5,
+        formatOptions: {
+          date: true,
+          colors: false,
+          compact: true
+        }
+      }
+    );
+    for (const type in types) {
+      const defaults = {
+        type,
+        ...this.options.defaults,
+        ...types[type]
+      };
+      this[type] = this._wrapLogFn(defaults);
+      this[type].raw = this._wrapLogFn(
+        defaults,
+        true
+      );
+    }
+    if (this.options.mockFn) {
+      this.mockTypes();
+    }
+    this._lastLog = {};
+  }
+  /**
+   * Gets the current log level of the Consola instance.
+   *
+   * @returns {number} The current log level.
+   */
+  get level() {
+    return this.options.level;
+  }
+  /**
+   * Sets the minimum log level that will be output by the instance.
+   *
+   * @param {number} level - The new log level to set.
+   */
+  set level(level) {
+    this.options.level = _normalizeLogLevel(
+      level,
+      this.options.types,
+      this.options.level
+    );
+  }
+  /**
+   * Displays a prompt to the user and returns the response.
+   * Throw an error if `prompt` is not supported by the current configuration.
+   *
+   * @template T
+   * @param {string} message - The message to display in the prompt.
+   * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
+   * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
+   */
+  prompt(message, opts) {
+    if (!this.options.prompt) {
+      throw new Error("prompt is not supported!");
+    }
+    return this.options.prompt(message, opts);
+  }
+  /**
+   * Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
+   *
+   * @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  create(options) {
+    const instance = new Consola({
+      ...this.options,
+      ...options
+    });
+    if (this._mockFn) {
+      instance.mockTypes(this._mockFn);
+    }
+    return instance;
+  }
+  /**
+   * Creates a new Consola instance with the specified default log object properties.
+   *
+   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withDefaults(defaults) {
+    return this.create({
+      ...this.options,
+      defaults: {
+        ...this.options.defaults,
+        ...defaults
+      }
+    });
+  }
+  /**
+   * Creates a new Consola instance with a specified tag, which will be included in every log.
+   *
+   * @param {string} tag - The tag to include in each log of the new instance.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withTag(tag) {
+    return this.withDefaults({
+      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
+    });
+  }
+  /**
+   * Adds a custom reporter to the Consola instance.
+   * Reporters will be called for each log message, depending on their implementation and log level.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  addReporter(reporter) {
+    this.options.reporters.push(reporter);
+    return this;
+  }
+  /**
+   * Removes a custom reporter from the Consola instance.
+   * If no reporter is specified, all reporters will be removed.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  removeReporter(reporter) {
+    if (reporter) {
+      const i = this.options.reporters.indexOf(reporter);
+      if (i !== -1) {
+        return this.options.reporters.splice(i, 1);
+      }
+    } else {
+      this.options.reporters.splice(0);
+    }
+    return this;
+  }
+  /**
+   * Replaces all reporters of the Consola instance with the specified array of reporters.
+   *
+   * @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  setReporters(reporters) {
+    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
+    return this;
+  }
+  wrapAll() {
+    this.wrapConsole();
+    this.wrapStd();
+  }
+  restoreAll() {
+    this.restoreConsole();
+    this.restoreStd();
+  }
+  /**
+   * Overrides console methods with Consola logging methods for consistent logging.
+   */
+  wrapConsole() {
+    for (const type in this.options.types) {
+      if (!console["__" + type]) {
+        console["__" + type] = console[type];
+      }
+      console[type] = this[type].raw;
+    }
+  }
+  /**
+   * Restores the original console methods, removing Consola overrides.
+   */
+  restoreConsole() {
+    for (const type in this.options.types) {
+      if (console["__" + type]) {
+        console[type] = console["__" + type];
+        delete console["__" + type];
+      }
+    }
+  }
+  /**
+   * Overrides standard output and error streams to redirect them through Consola.
+   */
+  wrapStd() {
+    this._wrapStream(this.options.stdout, "log");
+    this._wrapStream(this.options.stderr, "log");
+  }
+  _wrapStream(stream, type) {
+    if (!stream) {
+      return;
+    }
+    if (!stream.__write) {
+      stream.__write = stream.write;
+    }
+    stream.write = (data) => {
+      this[type].raw(String(data).trim());
+    };
+  }
+  /**
+   * Restores the original standard output and error streams, removing the Consola redirection.
+   */
+  restoreStd() {
+    this._restoreStream(this.options.stdout);
+    this._restoreStream(this.options.stderr);
+  }
+  _restoreStream(stream) {
+    if (!stream) {
+      return;
+    }
+    if (stream.__write) {
+      stream.write = stream.__write;
+      delete stream.__write;
+    }
+  }
+  /**
+   * Pauses logging, queues incoming logs until resumed.
+   */
+  pauseLogs() {
+    paused = true;
+  }
+  /**
+   * Resumes logging, processing any queued logs.
+   */
+  resumeLogs() {
+    paused = false;
+    const _queue = queue.splice(0);
+    for (const item of _queue) {
+      item[0]._logFn(item[1], item[2]);
+    }
+  }
+  /**
+   * Replaces logging methods with mocks if a mock function is provided.
+   *
+   * @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
+   */
+  mockTypes(mockFn) {
+    const _mockFn = mockFn || this.options.mockFn;
+    this._mockFn = _mockFn;
+    if (typeof _mockFn !== "function") {
+      return;
+    }
+    for (const type in this.options.types) {
+      this[type] = _mockFn(type, this.options.types[type]) || this[type];
+      this[type].raw = this[type];
+    }
+  }
+  _wrapLogFn(defaults, isRaw) {
+    return (...args) => {
+      if (paused) {
+        queue.push([this, defaults, args, isRaw]);
+        return;
+      }
+      return this._logFn(defaults, args, isRaw);
+    };
+  }
+  _logFn(defaults, args, isRaw) {
+    if ((defaults.level || 0) > this.level) {
+      return false;
+    }
+    const logObj = {
+      date: /* @__PURE__ */ new Date(),
+      args: [],
+      ...defaults,
+      level: _normalizeLogLevel(defaults.level, this.options.types)
+    };
+    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
+      Object.assign(logObj, args[0]);
+    } else {
+      logObj.args = [...args];
+    }
+    if (logObj.message) {
+      logObj.args.unshift(logObj.message);
+      delete logObj.message;
+    }
+    if (logObj.additional) {
+      if (!Array.isArray(logObj.additional)) {
+        logObj.additional = logObj.additional.split("\n");
+      }
+      logObj.args.push("\n" + logObj.additional.join("\n"));
+      delete logObj.additional;
+    }
+    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
+    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
+    const resolveLog = (newLog = false) => {
+      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
+      if (this._lastLog.object && repeated > 0) {
+        const args2 = [...this._lastLog.object.args];
+        if (repeated > 1) {
+          args2.push(`(repeated ${repeated} times)`);
+        }
+        this._log({ ...this._lastLog.object, args: args2 });
+        this._lastLog.count = 1;
+      }
+      if (newLog) {
+        this._lastLog.object = logObj;
+        this._log(logObj);
+      }
+    };
+    clearTimeout(this._lastLog.timeout);
+    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
+    this._lastLog.time = logObj.date;
+    if (diffTime < this.options.throttle) {
+      try {
+        const serializedLog = JSON.stringify([
+          logObj.type,
+          logObj.tag,
+          logObj.args
+        ]);
+        const isSameLog = this._lastLog.serialized === serializedLog;
+        this._lastLog.serialized = serializedLog;
+        if (isSameLog) {
+          this._lastLog.count = (this._lastLog.count || 0) + 1;
+          if (this._lastLog.count > this.options.throttleMin) {
+            this._lastLog.timeout = setTimeout(
+              resolveLog,
+              this.options.throttle
+            );
+            return;
+          }
+        }
+      } catch {
+      }
+    }
+    resolveLog(true);
+  }
+  _log(logObj) {
+    for (const reporter of this.options.reporters) {
+      reporter.log(logObj, {
+        options: this.options
+      });
+    }
+  }
+}
+function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
+  if (input === void 0) {
+    return defaultLevel;
+  }
+  if (typeof input === "number") {
+    return input;
+  }
+  if (types[input] && types[input].level !== void 0) {
+    return types[input].level;
+  }
+  return defaultLevel;
+}
+Consola.prototype.add = Consola.prototype.addReporter;
+Consola.prototype.remove = Consola.prototype.removeReporter;
+Consola.prototype.clear = Consola.prototype.removeReporter;
+Consola.prototype.withScope = Consola.prototype.withTag;
+Consola.prototype.mock = Consola.prototype.mockTypes;
+Consola.prototype.pause = Consola.prototype.pauseLogs;
+Consola.prototype.resume = Consola.prototype.resumeLogs;
+function createConsola$1(options = {}) {
+  return new Consola(options);
+}
+
+class BrowserReporter {
+  options;
+  defaultColor;
+  levelColorMap;
+  typeColorMap;
+  constructor(options) {
+    this.options = { ...options };
+    this.defaultColor = "#7f8c8d";
+    this.levelColorMap = {
+      0: "#c0392b",
+      // Red
+      1: "#f39c12",
+      // Yellow
+      3: "#00BCD4"
+      // Cyan
+    };
+    this.typeColorMap = {
+      success: "#2ecc71"
+      // Green
+    };
+  }
+  _getLogFn(level) {
+    if (level < 1) {
+      return console.__error || console.error;
+    }
+    if (level === 1) {
+      return console.__warn || console.warn;
+    }
+    return console.__log || console.log;
+  }
+  log(logObj) {
+    const consoleLogFn = this._getLogFn(logObj.level);
+    const type = logObj.type === "log" ? "" : logObj.type;
+    const tag = logObj.tag || "";
+    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
+    const style = `
+      background: ${color};
+      border-radius: 0.5em;
+      color: white;
+      font-weight: bold;
+      padding: 2px 0.5em;
+    `;
+    const badge = `%c${[tag, type].filter(Boolean).join(":")}`;
+    if (typeof logObj.args[0] === "string") {
+      consoleLogFn(
+        `${badge}%c ${logObj.args[0]}`,
+        style,
+        // Empty string as style resets to default console style
+        "",
+        ...logObj.args.slice(1)
+      );
+    } else {
+      consoleLogFn(badge, style, ...logObj.args);
+    }
+  }
+}
+
+function createConsola(options = {}) {
+  const consola2 = createConsola$1({
+    reporters: options.reporters || [new BrowserReporter({})],
+    prompt(message, options2 = {}) {
+      if (options2.type === "confirm") {
+        return Promise.resolve(confirm(message));
+      }
+      return Promise.resolve(prompt(message));
+    },
+    ...options
+  });
+  return consola2;
+}
+createConsola();
+
+const normalizeDescriptors=(error)=>{
+CORE_ERROR_PROPS.forEach((propName)=>{
+normalizeDescriptor$1(error,propName);
+});
+};
+
+const CORE_ERROR_PROPS=["name","message","stack","cause","errors"];
+
+const normalizeDescriptor$1=(error,propName)=>{
+const descriptor=getDescriptor(error,propName);
+
+if(descriptor===undefined){
+return
+}
+
+if(isReadonlyGetter(descriptor)){
+setErrorProperty$1(error,propName,error[propName]);
+return
+}
+
+if(isInvalidDescriptor(descriptor)){
+setErrorDescriptor(error,propName,descriptor);
+}
+};
+
+
+const getDescriptor=(value,propName)=>{
+const descriptor=Object.getOwnPropertyDescriptor(value,propName);
+
+if(descriptor!==undefined){
+return descriptor
+}
+
+const prototype=Object.getPrototypeOf(value);
+return prototype===null?undefined:getDescriptor(prototype,propName)
+};
+
+
+const isReadonlyGetter=({get,set})=>
+get!==undefined&&set===undefined;
+
+const isInvalidDescriptor=({enumerable,writable})=>
+enumerable||!writable;
+
+
+const setErrorProperty$1=(error,propName,value)=>{
+setErrorDescriptor(error,propName,{value});
+};
+
+
+const setErrorDescriptor=(error,propName,descriptor)=>{
+
+Object.defineProperty(error,propName,{
+...descriptor,
+...("get"in descriptor||"set"in descriptor?{}:{writable:true}),
+enumerable:false,
+configurable:true
+});
+};
+
+const normalizeAggregate=(error,recurse)=>{
+if(Array.isArray(error.errors)){
+const aggregateErrors=error.errors.
+filter(isDefined).
+map(recurse).
+filter(Boolean);
+setErrorProperty$1(error,"errors",aggregateErrors);
+}else if(isAggregateError(error)){
+setErrorProperty$1(error,"errors",[]);
+}else if(error.errors!==undefined){
+deleteAggregateErrors(error);
+}
+};
+
+const isDefined=(error)=>error!==undefined;
+
+const isAggregateError=(error)=>
+"AggregateError"in globalThis&&(
+error.name==="AggregateError"||error instanceof AggregateError);
+
+const deleteAggregateErrors=(error)=>{
+
+delete error.errors;
+
+if(error.errors!==undefined){
+setErrorProperty$1(error,"errors",[]);
+}
+};
+
+const normalizeCause=(error,recurse)=>{
+if(!("cause"in error)){
+return
+}
+
+const cause=error.cause===undefined?error.cause:recurse(error.cause);
+
+if(cause===undefined){
+
+delete error.cause;
+}else {
+setErrorProperty$1(error,"cause",cause);
+}
+};
+
+const isErrorInstance$1=(value)=>
+isInstanceOfError$1(value)||hasErrorTag$1(value);
+
+
+
+const isInstanceOfError$1=(value)=>{
+try{
+return value instanceof Error
+}catch{
+return false
+}
+};
+
+const hasErrorTag$1=(value)=>{
+try{
+return ERROR_TAGS$1.has(Object.prototype.toString.call(value))
+}catch{
+return false
+}
+};
+
+const ERROR_TAGS$1=new Set([
+
+"[object Error]",
+
+"[object DOMException]",
+
+"[object DOMError]",
+
+"[object Exception]"]
+);
+
+function isPlainObject(value) {
+	if (typeof value !== 'object' || value === null) {
+		return false;
+	}
+
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+const isNonModifiableError=(error)=>
+!Object.isExtensible(error)||
+CORE_ERROR_PROPS.some(
+(propName)=>
+isNonConfigurableProp(error,propName)||isThrowingProp(error,propName)
+);
+
+
+
+const isNonConfigurableProp=(error,propName)=>{
+const descriptor=Object.getOwnPropertyDescriptor(error,propName);
+return descriptor!==undefined&&!descriptor.configurable
+};
+
+
+const isThrowingProp=(error,propName)=>{
+try{
+
+error[propName];
+return false
+}catch{
+return true
+}
+};
+
+const setStack=(error)=>{
+const stack=getStack$3(error.message,error.name);
+setErrorProperty$1(error,"stack",stack);
+};
+
+
+
+
+
+
+
+const getStack$3=(message="",name="Error")=>{
+const StackError=getErrorClass(name);
+const{stack}=new StackError(message);
+return typeof stack==="string"&&stack!==""?
+stack:
+`${name}: ${message}`
+};
+
+
+
+
+
+const getErrorClass=(name)=>{
+const descriptor={
+value:name,
+enumerable:false,
+writable:true,
+configurable:true
+};
+
+const StackError=Object.defineProperty(
+class extends Error{},
+"name",
+descriptor
+);
+
+Object.defineProperty(StackError.prototype,"name",descriptor);
+return StackError
+};
+
+const copyObject=(object)=>{
+const objectCopy={};
+
+
+for(const propName of getPropsToCopy(object)){
+
+try{
+const value=object[propName];
+const{
+enumerable,
+configurable,
+writable=true
+}=getDescriptor(object,propName);
+
+Object.defineProperty(objectCopy,propName,{
+value,
+enumerable,
+configurable,
+writable
+});
+}catch{}
+}
+
+return objectCopy
+};
+
+
+
+
+
+const getPropsToCopy=(object)=>{
+const propNames=getOwnKeys(object);
+
+
+for(const propName of CORE_ERROR_PROPS){
+
+if(isInheritedProp(object,propName)){
+
+propNames.push(propName);
+}
+}
+
+return propNames
+};
+
+
+const getOwnKeys=(object)=>{
+try{
+return Reflect.ownKeys(object)
+}catch{
+return []
+}
+};
+
+
+const isInheritedProp=(object,propName)=>{
+try{
+return propName in object&&!Object.hasOwn(object,propName)
+}catch{
+return false
+}
+};
+
+const objectifyError=(object)=>{
+const{name,message,stack,cause,errors,...objectA}=copyObject(object);
+const messageA=getMessage$1(message,objectA);
+const error=newError(name,messageA);
+
+if(message===messageA){
+assignObjectProps(error,objectA);
+}
+
+Object.entries({name,stack,cause,errors}).forEach(
+([propName,propValue])=>{
+setNewErrorProperty(error,propName,propValue);
+}
+);
+
+if(stack===undefined){
+setStack(error);
+}
+
+return error
+};
+
+
+const getMessage$1=(message,object)=>
+typeof message==="string"&&message!==""?
+message:
+truncateMessage(safeJsonStringify(object));
+
+const safeJsonStringify=(object)=>{
+try{
+return JSON.stringify(object)
+}catch{
+return safeStringify$1(object)
+}
+};
+
+const safeStringify$1=(object)=>{
+try{
+return String(object)
+}catch{
+return "Invalid error"
+}
+};
+
+const truncateMessage=(message)=>
+message.length<MESSAGE_MAX_SIZE?
+message:
+`${message.slice(0,MESSAGE_MAX_SIZE)}...`;
+
+const MESSAGE_MAX_SIZE=1e3;
+
+const newError=(name,message)=>{
+if(name==="AggregateError"&&"AggregateError"in globalThis){
+return new AggregateError([],message)
+}
+
+if(name in NATIVE_ERRORS){
+return new NATIVE_ERRORS[name](message)
+}
+
+return new Error(message)
+};
+
+const NATIVE_ERRORS={
+Error,
+ReferenceError,
+TypeError,
+SyntaxError,
+RangeError,
+URIError,
+EvalError
+};
+
+
+const assignObjectProps=(error,object)=>{
+
+for(const propName in object){
+
+if(!(propName in error)){
+error[propName]=object[propName];
+}
+}
+};
+
+const setNewErrorProperty=(error,propName,propValue)=>{
+if(propValue!==undefined){
+setErrorProperty$1(error,propName,propValue);
+}
+};
+
+const stringifyError=(value)=>{
+try{
+const error=new Error(String(value));
+setStack(error);
+return error
+}catch(error_){
+return error_
+}
+};
+
+const{toString:objectToString}=Object.prototype;
+
+
+const createError=(value)=>{
+if(isErrorPlainObj(value)){
+return objectifyError(value)
+}
+
+if(!isErrorInstance$1(value)){
+return stringifyError(value)
+}
+
+if(isInvalidError(value)){
+return objectifyError(value)
+}
+
+return value
+};
+
+
+const isErrorPlainObj=(value)=>{
+try{
+return isPlainObject(value)
+}catch{
+return false
+}
+};
+
+const isInvalidError=(value)=>
+isProxy(value)||isNonModifiableError(value)||hasInvalidConstructor(value);
+
+
+
+
+const isProxy=(value)=>{
+try{
+return objectToString.call(value)==="[object Object]"
+}catch{
+return true
+}
+};
+
+
+
+const hasInvalidConstructor=(error)=>
+typeof error.constructor!=="function"||
+typeof error.constructor.name!=="string"||
+error.constructor.name===""||
+error.constructor.prototype!==Object.getPrototypeOf(error);
+
+const normalizeException=(error,{shallow=false}={})=>
+recurseException(error,[],shallow);
+
+const recurseException=(error,parents,shallow)=>{
+if(parents.includes(error)){
+return
+}
+
+const recurse=shallow?
+identity:
+(innerError)=>recurseException(innerError,[...parents,error],shallow);
+
+const errorA=createError(error);
+normalizeProps(errorA,recurse);
+return errorA
+};
+
+const identity=(error)=>error;
+
+const normalizeProps=(error,recurse)=>{
+normalizeName(error);
+normalizeMessage(error);
+normalizeStack(error);
+normalizeCause(error,recurse);
+normalizeAggregate(error,recurse);
+normalizeDescriptors(error);
+};
+
+
+
+
+
+
+const normalizeName=(error)=>{
+if(isDefinedString$1(error.name)){
+return
+}
+
+const prototypeName=Object.getPrototypeOf(error).name;
+const name=isDefinedString$1(prototypeName)?
+prototypeName:
+error.constructor.name;
+setErrorProperty$1(error,"name",name);
+};
+
+
+const normalizeMessage=(error)=>{
+if(!isDefinedString$1(error.message)){
+setErrorProperty$1(error,"message","");
+}
+};
+
+
+const normalizeStack=(error)=>{
+if(!isDefinedString$1(error.stack)){
+setStack(error);
+}
+};
+
+const isDefinedString$1=(value)=>typeof value==="string"&&value!=="";
+
+const normalizeArgs$1=(error,ErrorClass,currentName=error.name)=>{
+validateErrorClass(ErrorClass);
+
+if(typeof currentName!=="string"){
+throw new TypeError(`currentName must be a string: ${currentName}`)
+}
+
+return currentName
+};
+
+const validateErrorClass=(ErrorClass)=>{
+if(!isClass(ErrorClass)){
+throw new TypeError(`ErrorClass must be a class: ${ErrorClass}`)
+}
+
+if(!isErrorClass(ErrorClass.prototype)){
+throw new TypeError(`ErrorClass must inherit from Error: ${ErrorClass}`)
+}
+
+if(!hasConstructor(ErrorClass)){
+throw new TypeError(
+`ErrorClass must be have a valid constructor: ${ErrorClass}`
+)
+}
+};
+
+const isClass=(ErrorClass)=>
+typeof ErrorClass==="function"&&
+typeof ErrorClass.prototype==="object"&&
+ErrorClass.prototype!==null;
+
+
+const isErrorClass=(prototype)=>
+prototype!==null&&(
+prototype.name==="Error"||isErrorClass(Object.getPrototypeOf(prototype)));
+
+const hasConstructor=(ErrorClass)=>
+typeof ErrorClass.prototype.constructor==="function";
+
+const setNonEnumProp$1=(error,propName,value)=>{
+
+Object.defineProperty(error,propName,{
+value,
+enumerable:false,
+writable:true,
+configurable:true
+});
+};
+
+const updatePrototype=(error,ErrorClass)=>{
+if(Object.getPrototypeOf(error)===ErrorClass.prototype){
+return
+}
+
+setPrototype(error,ErrorClass);
+deleteOwnProperty(error,"constructor");
+fixName(error,ErrorClass);
+};
+
+
+
+
+
+const setPrototype=(error,ErrorClass)=>{
+
+Object.setPrototypeOf(error,ErrorClass.prototype);
+};
+
+
+
+
+
+
+
+
+
+
+const fixName=(error,ErrorClass)=>{
+deleteOwnProperty(error,"name");
+
+const prototypeName=getClassName(ErrorClass.prototype);
+
+if(error.name!==prototypeName){
+setNonEnumProp$1(error,"name",prototypeName);
+}
+};
+
+const getClassName=(prototype)=>
+getPrototypeName(prototype)??
+getConstructorName(prototype)??
+getClassName(Object.getPrototypeOf(prototype));
+
+const getPrototypeName=(prototype)=>
+Object.hasOwn(prototype,"name")&&isDefinedString(prototype.name)?
+prototype.name:
+undefined;
+
+const getConstructorName=(prototype)=>
+typeof prototype.constructor==="function"&&
+isDefinedString(prototype.constructor.name)?
+prototype.constructor.name:
+undefined;
+
+const isDefinedString=(value)=>typeof value==="string"&&value!=="";
+
+
+
+const deleteOwnProperty=(error,propName)=>{
+if(Object.hasOwn(error,propName)){
+
+delete error[propName];
+}
+};
+
+const updateStack$1=(error,currentName)=>{
+if(!shouldUpdateStack(error,currentName)){
+return
+}
+
+const stack=getStack$2(error,currentName);
+setNonEnumProp$1(error,"stack",stack);
+};
+
+const shouldUpdateStack=(error,currentName)=>
+currentName!==error.name&&
+currentName!==""&&
+error.stack.includes(currentName)&&
+stackIncludesName();
+
+
+const stackIncludesName=()=>{
+
+class StackError extends Error{}
+const descriptor={
+value:EXAMPLE_NAME,
+enumerable:false,
+writable:true,
+configurable:true
+};
+
+Object.defineProperty(StackError,"name",descriptor);
+
+Object.defineProperty(StackError.prototype,"name",descriptor);
+const{stack}=new StackError("");
+return typeof stack==="string"&&stack.includes(EXAMPLE_NAME)
+};
+
+const EXAMPLE_NAME="SetErrorClassError";
+
+
+
+
+
+
+
+
+const getStack$2=({name,stack},currentName)=>{
+if(stack.startsWith(`${currentName}: `)){
+return stack.replace(currentName,name)
+}
+
+const replacers=getReplacers$1(currentName,name);
+const[fromA,to]=replacers.find(([from])=>stack.includes(from));
+return stack.replace(fromA,to)
+};
+
+
+
+const getReplacers$1=(currentName,newName)=>[
+[`\n${currentName}: `,`\n${newName}: `],
+[`${currentName}: `,`${newName}: `],
+[`${currentName} `,`${newName} `],
+[currentName,newName]];
+
+const setErrorClass=(error,ErrorClass,currentName)=>{
+const errorA=normalizeException(error);
+const currentNameA=normalizeArgs$1(errorA,ErrorClass,currentName);
+updatePrototype(errorA,ErrorClass);
+updateStack$1(errorA,currentNameA);
+return errorA
+};
+
+const mergeDescriptors=(newDescriptor,currentDescriptor)=>
+currentDescriptor.configurable===false?
+mergeNonConfig(newDescriptor,currentDescriptor):
+mergeConfig(newDescriptor,currentDescriptor);
+
+
+
+
+const mergeNonConfig=(newDescriptor,currentDescriptor)=>({
+...currentDescriptor,
+...getNonConfigWritable(newDescriptor,currentDescriptor),
+...getNonConfigValue(newDescriptor,currentDescriptor)
+});
+
+const getNonConfigWritable=(newDescriptor,currentDescriptor)=>
+currentDescriptor.writable===true&&newDescriptor.writable===false?
+{writable:false}:
+{};
+
+const getNonConfigValue=(newDescriptor,currentDescriptor)=>
+newDescriptor.hasValue&&
+"value"in currentDescriptor&&
+currentDescriptor.writable===true?
+{value:newDescriptor.value}:
+{};
+
+const mergeConfig=(newDescriptor,currentDescriptor)=>{
+const enumerable=mergeDescriptor(
+newDescriptor.enumerable,
+currentDescriptor.enumerable,
+true
+);
+const writable=mergeDescriptor(
+newDescriptor.writable,
+currentDescriptor.writable,
+true
+);
+const configurable=mergeDescriptor(
+newDescriptor.configurable,
+currentDescriptor.configurable,
+true
+);
+const valueProps=mergeValue(newDescriptor,currentDescriptor,writable);
+return {...valueProps,enumerable,configurable}
+};
+
+const mergeValue=(newDescriptor,currentDescriptor,writable)=>{
+if(newDescriptor.hasValue){
+return {value:newDescriptor.value,writable}
+}
+
+if(!hasGetSet(newDescriptor)&&!hasGetSet(currentDescriptor)){
+return {value:currentDescriptor.value,writable}
+}
+
+return {
+get:mergeDescriptor(newDescriptor.get,currentDescriptor.get),
+set:mergeDescriptor(newDescriptor.set,currentDescriptor.set)
+}
+};
+
+const hasGetSet=({get,set})=>get!==undefined||set!==undefined;
+
+const mergeDescriptor=(newValue,currentValue,defaultValue)=>
+newValue??currentValue??defaultValue;
+
+const normalizeInput=(input,key,newDescriptor)=>{
+if(!isAnyObj(input)){
+throw new TypeError(`Argument must be an object: ${input}`)
+}
+
+if(!isValidKey(key)){
+throw new TypeError(
+`Property key must be a string, a symbol or an integer: ${key}`
+)
+}
+
+return normalizeDescriptor(newDescriptor)
+};
+
+const isAnyObj=(value)=>typeof value==="object"&&value!==null;
+
+const isValidKey=(key)=>{
+const type=typeof key;
+return type==="string"||type==="symbol"||type==="number"
+};
+
+const normalizeDescriptor=(newDescriptor)=>{
+if(!isPlainObject(newDescriptor)){
+throw new TypeError(`Descriptor must be a plain object: ${newDescriptor}`)
+}
+
+const{
+enumerable,
+writable,
+configurable,
+value,
+get,
+set,
+...unknownProps
+}=newDescriptor;
+const hasValue=("value"in newDescriptor);
+validateDescriptor({
+enumerable,
+writable,
+configurable,
+get,
+set,
+unknownProps,
+hasValue
+});
+return {enumerable,writable,configurable,value,get,set,hasValue}
+};
+
+const validateDescriptor=({
+enumerable,
+writable,
+configurable,
+get,
+set,
+unknownProps,
+hasValue
+})=>{
+validateGetSet(hasValue,get,"get");
+validateGetSet(hasValue,set,"set");
+validateBoolean(enumerable,"enumerable");
+validateBoolean(writable,"writable");
+validateBoolean(configurable,"configurable");
+validateUnknownProps(unknownProps);
+};
+
+const validateGetSet=(hasValue,getSet,propName)=>{
+validateFunction(getSet,propName);
+
+if(hasValue&&getSet!==undefined){
+throw new TypeError(
+`Descriptor property "value" and "${propName}" must not both be defined: ${getSet}`
+)
+}
+};
+
+const validateFunction=(propValue,propName)=>{
+if(propValue!==undefined&&typeof propValue!=="function"){
+throw new TypeError(
+`Descriptor property "${propName}" must be a function: ${propValue}`
+)
+}
+};
+
+const validateBoolean=(propValue,propName)=>{
+if(propValue!==undefined&&typeof propValue!=="boolean"){
+throw new TypeError(
+`Descriptor property "${propName}" must be a boolean: ${propValue}`
+)
+}
+};
+
+const validateUnknownProps=(unknownProps)=>{
+const[unknownProp]=Object.keys(unknownProps);
+
+if(unknownProp!==undefined){
+throw new TypeError(
+`Unknown descriptor property "${unknownProp}": ${unknownProps[unknownProp]}`
+)
+}
+};
+
+const redefineProperty=(input,key,newDescriptor)=>{
+const newDescriptorA=normalizeInput(input,key,newDescriptor);
+const currentDescriptor=getCurrentDescriptor(input,key);
+const finalDescriptor=mergeDescriptors(newDescriptorA,currentDescriptor);
+setProperty(input,key,finalDescriptor);
+return input
+};
+
+
+const getCurrentDescriptor=(input,key)=>{
+const descriptor=Object.getOwnPropertyDescriptor(input,key);
+
+if(descriptor!==undefined){
+return descriptor
+}
+
+const prototype=Object.getPrototypeOf(input);
+return prototype===null?{}:getCurrentDescriptor(prototype,key)
+};
+
+
+const setProperty=(input,key,finalDescriptor)=>{
+try{
+
+Object.defineProperty(input,key,finalDescriptor);
+}catch{}
+};
+
+const assignProp=(error,propName,propValue)=>{
+if(propValue!==undefined){
+return setProp(error,propName,propValue)
+}
+
+try{
+
+delete error[propName];
+}catch{}
+
+if(error[propName]!==undefined){
+return setProp(error,propName)
+}
+};
+
+const setProp=(error,propName,propValue)=>{
+const nonEnum=getNonEnum(propName);
+redefineProperty(error,propName,{value:propValue,...nonEnum});
+};
+
+
+const getNonEnum=(propName)=>
+typeof propName==="string"&&propName.startsWith("_")?
+{enumerable:false}:
+{};
+
+const isErrorInstance=(value)=>
+isInstanceOfError(value)||hasErrorTag(value);
+
+
+
+const isInstanceOfError=(value)=>{
+try{
+return value instanceof Error
+}catch{
+return false
+}
+};
+
+const hasErrorTag=(value)=>{
+try{
+return ERROR_TAGS.has(Object.prototype.toString.call(value))
+}catch{
+return false
+}
+};
+
+const ERROR_TAGS=new Set([
+
+"[object Error]",
+
+"[object DOMException]",
+
+"[object DOMError]",
+
+"[object Exception]"]
+);
+
+const normalizeOptions=(error,props,opts={})=>{
+validateErrorOrObject(error,"First argument");
+validateErrorOrObject(props,"Second argument");
+
+if(!isPlainObject(opts)){
+throw new TypeError(`Options must be a plain object: ${opts}`)
+}
+
+const{soft=false}=opts;
+
+if(typeof soft!=="boolean"){
+throw new TypeError(`Option "soft" must be a boolean: ${soft}`)
+}
+
+return {soft}
+};
+
+const validateErrorOrObject=(value,prefix)=>{
+if(value===undefined){
+throw new TypeError(`${prefix} is required.`)
+}
+
+if(!isErrorOrObject(value)){
+throw new TypeError(
+`${prefix} must be a plain object or an error: ${value}`
+)
+}
+};
+
+const isErrorOrObject=(value)=>isPlainObject(value)||isErrorInstance(value);
+
+const shouldSkipProp=({error,props,propName,soft})=>
+isIgnoredPropName(propName)||
+!isEnum.call(props,propName)||
+soft&&error[propName]!==undefined;
+
+const isIgnoredPropName=(propName)=>
+propName in CHECK_ERROR||IGNORED_PROPS.has(propName);
+
+
+
+
+const CHECK_ERROR=new Error("check");
+
+
+
+const IGNORED_PROPS=new Set(["prototype","errors","cause"]);
+
+const{propertyIsEnumerable:isEnum}=Object.prototype;
+
+const setErrorProps=(error,props,opts)=>{
+const{soft}=normalizeOptions(error,props,opts);
+
+
+for(const propName of Reflect.ownKeys(props)){
+setErrorProp({error,props,propName,soft});
+}
+
+return error
+};
+
+
+
+
+
+const setErrorProp=({error,props,propName,soft})=>{
+if(!shouldSkipProp({error,props,propName,soft})){
+assignProp(error,propName,props[propName]);
+}
+};
+
+const setErrorProperty=(error,propName,value)=>{
+
+Object.defineProperty(error,propName,{
+value,
+writable:true,
+enumerable:false,
+configurable:true
+});
+};
+
+const mergeAggregateCauses=(parent,recurse)=>{
+if(parent.errors===undefined){
+return
+}
+
+const errors=parent.errors.
+map((error)=>recurse(error).error).
+filter(Boolean);
+setErrorProperty(parent,"errors",errors);
+};
+
+const mergeAggregateErrors=({target,source,parent,child})=>{
+if(!hasErrors(target)){
+mergeSourceErrors(target,source);
+return
+}
+
+if(hasErrors(source)){
+setErrorProperty(target,"errors",[...child.errors,...parent.errors]);
+}
+};
+
+const mergeSourceErrors=(target,source)=>{
+if(source.errors!==undefined){
+setErrorProperty(target,"errors",source.errors);
+}
+};
+
+const hasErrors=(targetOrSource)=>
+targetOrSource.errors!==undefined&&targetOrSource.errors.length!==0;
+
+const normalizeArgs=(
+error,
+newMessage,
+currentMessage=error.message)=>
+{
+if(typeof newMessage!=="string"){
+throw new TypeError(`newMessage must be a string: ${newMessage}`)
+}
+
+if(typeof currentMessage!=="string"){
+throw new TypeError(`currentMessage must be a string: ${currentMessage}`)
+}
+
+return currentMessage
+};
+
+const getStack$1=({name,stack},newMessage,currentMessage)=>
+currentMessage!==""&&stack.includes(currentMessage)?
+replaceMessage({name,stack,newMessage,currentMessage}):
+insertMessage(name,stack,newMessage);
+
+
+
+const replaceMessage=({name,stack,newMessage,currentMessage})=>{
+const replacers=getReplacers(name,newMessage,currentMessage);
+const[fromA,to]=replacers.find(([from])=>stack.includes(from));
+return stack.replace(fromA,to)
+};
+
+
+
+const getReplacers=(name,newMessage,currentMessage)=>[
+[`${name}: ${currentMessage}`,`${name}: ${newMessage}`],
+[`: ${currentMessage}`,`: ${newMessage}`],
+[`\n${currentMessage}`,`\n${newMessage}`],
+[` ${currentMessage}`,` ${newMessage}`],
+[currentMessage,newMessage]];
+
+
+const insertMessage=(name,stack,newMessage)=>{
+const nameAndColon=`${name}: `;
+const newMessageA=newMessage.trimEnd();
+
+if(stack===name||stack.startsWith(`${name}\n`)){
+return stack.replace(name,`${nameAndColon}${newMessageA}`)
+}
+
+return stack.startsWith(nameAndColon)?
+stack.replace(nameAndColon,`${nameAndColon}${newMessageA}\n`):
+`${nameAndColon}${newMessageA}\n${stack}`
+};
+
+const setErrorMessage=(error,newMessage,currentMessage)=>{
+const errorA=normalizeException(error);
+const currentMessageA=normalizeArgs(errorA,newMessage,currentMessage);
+setNonEnumProp(errorA,"message",newMessage);
+updateStack(errorA,newMessage,currentMessageA);
+return errorA
+};
+
+
+
+const updateStack=(error,newMessage,currentMessage)=>{
+if(newMessage===currentMessage||!stackIncludesMessage()){
+return
+}
+
+const stack=getStack$1(error,newMessage,currentMessage);
+setNonEnumProp(error,"stack",stack);
+};
+
+
+const stackIncludesMessage=()=>{
+const{stack}=new Error(EXAMPLE_MESSAGE);
+return typeof stack==="string"&&stack.includes(EXAMPLE_MESSAGE)
+};
+
+const EXAMPLE_MESSAGE="set-error-message test message";
+
+const setNonEnumProp=(error,propName,value)=>{
+
+Object.defineProperty(error,propName,{
+value,
+enumerable:false,
+writable:true,
+configurable:true
+});
+};
+
+const wrapErrorMessage=(error,newMessage,oldMessage)=>{
+if(typeof newMessage!=="string"){
+throw new TypeError(
+`Second argument must be a message string: ${newMessage}`
+)
+}
+
+const errorA=normalizeException(error);
+const message=getMessage(newMessage,errorA.message);
+return setErrorMessage(errorA,message,oldMessage)
+};
+
+
+
+
+
+
+
+
+
+const getMessage=(rawNewMessage,rawCurrentMessage)=>{
+const newMessage=rawNewMessage.trim();
+const currentMessage=rawCurrentMessage.trim();
+
+if(newMessage===""){
+return currentMessage
+}
+
+if(currentMessage===""){
+return newMessage
+}
+
+return concatMessages(newMessage,currentMessage,rawNewMessage)
+};
+
+const concatMessages=(newMessage,currentMessage,rawNewMessage)=>{
+if(!newMessage.endsWith(PREPEND_CHAR)){
+return `${currentMessage}\n${newMessage}`
+}
+
+return rawNewMessage.endsWith(PREPEND_NEWLINE_CHAR)?
+`${newMessage}\n${currentMessage}`:
+`${newMessage} ${currentMessage}`
+};
+
+const PREPEND_CHAR=":";
+const PREPEND_NEWLINE_CHAR="\n";
+
+const mergeMessage=({parent,child,target,stackError})=>{
+const parentMessage=parent.message;
+
+target.message=child.message;
+return wrapErrorMessage(target,parentMessage,stackError.message)
+};
+
+const hasStack=(error,stack)=>getStack(error)===stack;
+
+
+
+
+const getStack=(error)=>
+typeof error==="object"&&error!==null?error.stack:undefined;
+
+
+
+
+
+
+
+
+
+
+const mergeStack=({wrap,target,source,childHasStack})=>{
+if(wrap===childHasStack){
+return target
+}
+
+setErrorProperty(target,"stack",source.stack);
+return source
+};
+
+const getWrap=(parent)=>{
+const{wrap,name}=parent;
+
+if(typeof wrap!=="boolean"){
+return name==="Error"
+}
+
+if(Object.hasOwn(parent,"wrap")){
+
+delete parent.wrap;
+}
+
+return wrap
+};
+
+const mergeErrorCause=(error)=>mergeError(error,[]).error;
+
+
+
+
+
+
+const mergeError=(error,parents)=>{
+if(parents.includes(error)){
+return {}
+}
+
+const recurse=(innerError)=>mergeError(innerError,[...parents,error]);
+const stack=getStack(error);
+const errorA=normalizeException(error,{shallow:true});
+const parentHasStack=hasStack(errorA,stack);
+
+mergeAggregateCauses(errorA,recurse);
+const{parent:errorB,childHasStack}=mergeCause(errorA,recurse);
+const errorHasStack=parentHasStack||childHasStack;
+return {error:errorB,errorHasStack}
+};
+
+
+
+const mergeCause=(parent,recurse)=>{
+const wrap=getWrap(parent);
+
+if(parent.cause===undefined){
+return {parent,childHasStack:false}
+}
+
+const{error:child,errorHasStack:childHasStack}=recurse(parent.cause);
+
+delete parent.cause;
+const parentA=mergeChild({parent,child,childHasStack,wrap});
+return {parent:parentA,childHasStack}
+};
+
+const mergeChild=({parent,child,childHasStack,wrap})=>{
+if(child===undefined){
+return parent
+}
+
+const[target,source]=wrap?[child,parent]:[parent,child];
+const stackError=mergeStack({wrap,target,source,childHasStack});
+const targetA=setErrorClass(target,target.constructor,stackError.name);
+const targetB=mergeMessage({parent,child,target:targetA,stackError});
+mergeAggregateErrors({target:targetB,source,parent,child});
+const targetC=setErrorProps(targetB,source,{soft:!wrap});
+return targetC
+};
+
+function safeStringifyReplacer(seen) {
+	return function (key, value) {
+		// Handle objects with a custom `.toJSON()` method.
+		if (typeof value?.toJSON === 'function') {
+			value = value.toJSON();
+		}
+
+		if (!(value !== null && typeof value === 'object')) {
+			return value;
+		}
+
+		if (seen.has(value)) {
+			return '[Circular]';
+		}
+
+		seen.add(value);
+
+		const newValue = Array.isArray(value) ? [] : {};
+
+		for (const [key2, value2] of Object.entries(value)) {
+			newValue[key2] = safeStringifyReplacer(seen)(key2, value2);
+		}
+
+		seen.delete(value);
+
+		return newValue;
+	};
+}
+
+function safeStringify(object, {indentation} = {}) {
+	const seen = new WeakSet();
+	return JSON.stringify(object, safeStringifyReplacer(seen), indentation);
+}
+
+const defaultParseStack = (stack) => {
+  const lines = stack.split("\n").map((l) => l.trim().replace("file://", ""));
+  return lines;
+};
+function formattedLogObj(logObj, parseStack = defaultParseStack) {
+  const result = {
+    message: ""
+  };
+  const error = logObj.args.find((a) => a instanceof Error);
+  if (!error) {
+    result.message = logObj.args.map((arg) => typeof arg === "string" ? arg : safeStringify(arg)).join("; ");
+    if (typeof logObj.tag === "string" && logObj.tag.length > 0) {
+      result.message = `[${logObj.tag}] ${result.message}`;
+    }
+    return result;
+  }
+  const mergedErr = logObj.args.reduce(
+    (acc, arg) => {
+      if (arg === error) {
+        return acc;
+      }
+      const msg = typeof arg === "string" ? arg : safeStringify(arg);
+      return wrapErrorMessage(acc, msg);
+    },
+    mergeErrorCause(error)
+  );
+  result.message = mergedErr.message;
+  result.error = {
+    message: mergedErr.message,
+    name: mergedErr.name
+  };
+  if (mergedErr.stack) {
+    const stack = parseStack(mergedErr.stack);
+    result.error.stack = stack.join("\n");
+    result.message += "\n" + stack.slice(1).map((l) => "  " + l).join("\n");
+  }
+  if (typeof logObj.tag === "string" && logObj.tag.length > 0) {
+    result.message = `[${logObj.tag}] ${result.message}`;
+  }
+  return result;
+}
+
+const consola = createConsola({
+  level: LogLevels.debug
+});
+function formatLogObj(logObj) {
+  return formattedLogObj(logObj);
+}
+
+exports.LogLevels = LogLevels;
+exports.consola = consola;
+exports.formatLogObj = formatLogObj;
+exports.logger = consola;
+exports.rootLogger = consola;