@likec4/log 1.21.1 → 1.22.1

package/dist/browser.mjs

@@ -1,1932 +0,0 @@
-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 === undefined) {
-      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 === undefined) {
-    return defaultLevel;
-  }
-  if (typeof input === "number") {
-    return input;
-  }
-  if (types[input] && types[input].level !== undefined) {
-    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);
-}
-
-export { LogLevels, consola, formatLogObj, consola as logger, consola as rootLogger };