@likec4/log 1.26.1 → 1.29.0

package/dist/index.cjs

@@ -1,1485 +0,0 @@
-'use strict';
-
-const logtape = require('@logtape/logtape');
-
-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 parseStack = (stack) => {
-  const lines = stack.split("\n").map((l) => {
-    let replaced = l.trim().replace("file://", "");
-    return replaced;
-  });
-  return lines;
-};
-function ident(value, identation = 2) {
-  value = Array.isArray(value) ? value : value.split("\n");
-  return value.map((l) => `${" ".repeat(identation)}${l}`).join("\n");
-}
-function loggable(error) {
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    const mergedErr = mergeErrorCause(error);
-    if (mergedErr.stack) {
-      const stack = parseStack(mergedErr.stack);
-      return mergedErr.message + "\n" + ident(stack.slice(1));
-    }
-    return mergedErr.message;
-  }
-  return safeStringify(error);
-}
-
-function gerErrorFromLogRecord(record) {
-  const errors = Object.values(record.properties).filter((v) => v instanceof Error).map((err) => {
-    const mergedErr = mergeErrorCause(err);
-    if (mergedErr.stack) {
-      mergedErr.stack = parseStack(mergedErr.stack).join("\n");
-    }
-    return mergedErr;
-  });
-  if (errors.length === 0) {
-    return null;
-  }
-  return errors.length === 1 ? errors[0] : new AggregateError(errors);
-}
-function errorFromLogRecord(record) {
-  const error = gerErrorFromLogRecord(record);
-  if (error && typeof record.rawMessage === "string") {
-    return wrapErrorMessage(error, record.rawMessage + "\n");
-  }
-  return error;
-}
-function appendErrorToMessage(values, color) {
-  const error = gerErrorFromLogRecord(values.record);
-  if (error) {
-    let errorMessge = error.message;
-    if (error.stack) {
-      errorMessge = errorMessge + "\n" + ident(error.stack.split("\n").slice(1));
-    }
-    if (color) {
-      errorMessge = `${ansiColors.red}${errorMessge}${RESET}`;
-    }
-    return {
-      ...values,
-      message: values.message + "\n" + ident(errorMessge)
-    };
-  }
-  return values;
-}
-const levelAbbreviations = {
-  "debug": "DEBUG",
-  "info": "INFO ",
-  "warning": "WARN ",
-  "error": "ERROR",
-  "fatal": "FATAL"
-};
-function getMessageOnlyFormatter() {
-  return getTextFormatter({
-    format: ({ message }) => {
-      return message;
-    }
-  });
-}
-const level = (l) => levelAbbreviations[l];
-function getTextFormatter(options) {
-  const _format = options?.format ?? (({ timestamp, level: level2, category, message }) => {
-    return `${timestamp} ${level2} ${category} ${message}`;
-  });
-  return logtape.getTextFormatter({
-    timestamp: "time",
-    level,
-    category: ".",
-    ...options,
-    format: (values) => {
-      return _format(appendErrorToMessage(values));
-    }
-  });
-}
-const RESET = "\x1B[0m";
-const ansiColors = {
-  // black: "\x1b[30m",
-  red: "\x1B[31m"
-  // green: "\x1b[32m",
-  // yellow: "\x1b[33m",
-  // blue: "\x1b[34m",
-  // magenta: "\x1b[35m",
-  // cyan: "\x1b[36m",
-  // white: "\x1b[37m",
-};
-function getAnsiColorFormatter(options) {
-  const _format = options?.format ?? (({ timestamp, level: level2, category, message }) => {
-    return `${timestamp} ${level2} ${category} ${message}`;
-  });
-  return logtape.getAnsiColorFormatter({
-    timestamp: "time",
-    level,
-    categoryStyle: "bold",
-    categoryColor: "cyan",
-    category: ".",
-    ...options,
-    format: (values) => {
-      return _format(appendErrorToMessage(values, true));
-    }
-  });
-}
-function getConsoleSink(options) {
-  return logtape.getConsoleSink({
-    formatter: getAnsiColorFormatter(),
-    ...options
-  });
-}
-
-const logger = logtape.getLogger("likec4");
-function createLogger(subcategory) {
-  return logger.getChild(subcategory);
-}
-let configureWasCalled = false;
-async function configureLogger(config) {
-  try {
-    configureWasCalled = true;
-    const sinks = config?.sinks ?? {};
-    await logtape.configure({
-      ...config,
-      sinks: {
-        ...sinks,
-        // @ts-expect-error console is not a valid sink id
-        console: sinks["console"] ?? getConsoleSink()
-      },
-      loggers: [
-        { category: ["logtape", "meta"], sinks: ["console"], lowestLevel: "warning" },
-        ...config?.loggers ?? [
-          {
-            category: "likec4",
-            sinks: ["console"],
-            lowestLevel: "debug"
-          }
-        ]
-      ]
-    });
-  } catch (e) {
-    console.error(e);
-  }
-}
-function ensureLoggerIsConfigured() {
-  if (!configureWasCalled) {
-    configureLogger();
-    console.warn("logger automatically configured with default settings");
-  }
-}
-
-exports.withFilter = logtape.withFilter;
-exports.configureLogger = configureLogger;
-exports.consola = logger;
-exports.createLogger = createLogger;
-exports.ensureLoggerIsConfigured = ensureLoggerIsConfigured;
-exports.errorFromLogRecord = errorFromLogRecord;
-exports.getAnsiColorFormatter = getAnsiColorFormatter;
-exports.getConsoleSink = getConsoleSink;
-exports.getMessageOnlyFormatter = getMessageOnlyFormatter;
-exports.getTextFormatter = getTextFormatter;
-exports.loggable = loggable;
-exports.logger = logger;
-exports.rootLogger = logger;