@likec4/log 1.18.0 → 1.19.1

package/dist/browser.mjs

@@ -67,11 +67,25 @@ const LogTypes = {
   }
 };
 
-function isObject(value) {
-  return value !== null && typeof value === "object";
+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 (!isObject(defaults)) {
+  if (!isPlainObject$1(defaults)) {
     return _defu(baseObject, {}, namespace);
   }
   const object = Object.assign({}, defaults);
@@ -85,7 +99,7 @@ function _defu(baseObject, defaults, namespace = ".", merger) {
     }
     if (Array.isArray(value) && Array.isArray(object[key])) {
       object[key] = [...value, ...object[key]];
-    } else if (isObject(value) && isObject(object[key])) {
+    } else if (isPlainObject$1(value) && isPlainObject$1(object[key])) {
       object[key] = _defu(
         value,
         object[key],
@@ -104,11 +118,11 @@ function createDefu(merger) {
 }
 const defu = createDefu();
 
-function isPlainObject(obj) {
+function isPlainObject$2(obj) {
   return Object.prototype.toString.call(obj) === "[object Object]";
 }
 function isLogObj(arg) {
-  if (!isPlainObject(arg)) {
+  if (!isPlainObject$2(arg)) {
     return false;
   }
   if (!arg.message && !arg.args) {
@@ -123,6 +137,14 @@ function isLogObj(arg) {
 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(
@@ -160,9 +182,19 @@ class Consola {
     }
     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,
@@ -170,12 +202,27 @@ class Consola {
       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,
@@ -186,6 +233,12 @@ class Consola {
     }
     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,
@@ -195,19 +248,39 @@ class Consola {
       }
     });
   }
+  /**
+   * 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 >= 0) {
+      if (i !== -1) {
         return this.options.reporters.splice(i, 1);
       }
     } else {
@@ -215,6 +288,12 @@ class Consola {
     }
     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;
@@ -227,6 +306,9 @@ class Consola {
     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]) {
@@ -235,6 +317,9 @@ class Consola {
       console[type] = this[type].raw;
     }
   }
+  /**
+   * Restores the original console methods, removing Consola overrides.
+   */
   restoreConsole() {
     for (const type in this.options.types) {
       if (console["__" + type]) {
@@ -243,6 +328,9 @@ class Consola {
       }
     }
   }
+  /**
+   * Overrides standard output and error streams to redirect them through Consola.
+   */
   wrapStd() {
     this._wrapStream(this.options.stdout, "log");
     this._wrapStream(this.options.stderr, "log");
@@ -258,6 +346,9 @@ class Consola {
       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);
@@ -271,9 +362,15 @@ class Consola {
       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);
@@ -281,6 +378,11 @@ class Consola {
       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;
@@ -403,6 +505,10 @@ function createConsola$1(options = {}) {
 }
 
 class BrowserReporter {
+  options;
+  defaultColor;
+  levelColorMap;
+  typeColorMap;
   constructor(options) {
     this.options = { ...options };
     this.defaultColor = "#7f8c8d";
@@ -470,8 +576,1357 @@ function createConsola(options = {}) {
 }
 createConsola();
 
-const consola = createConsola({
-  level: LogLevels.debug
+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, consola as logger, consola as rootLogger };
+export { LogLevels, consola, formatLogObj, consola as logger, consola as rootLogger };