@likec4/log 1.46.0 → 1.48.0

package/dist/_chunks/libs/merge-error-cause.mjs

@@ -0,0 +1,746 @@
+import { t as main_default$7 } from "./is-error-instance.mjs";
+import { t as isPlainObject } from "./is-plain-obj.mjs";
+
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/descriptors.js
+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 === void 0) 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 !== void 0) return descriptor;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null ? void 0 : getDescriptor(prototype, propName);
+};
+const isReadonlyGetter = ({ get, set }) => get !== void 0 && set === void 0;
+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
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/aggregate.js
+const normalizeAggregate = (error, recurse) => {
+	if (Array.isArray(error.errors)) setErrorProperty$1(error, "errors", error.errors.filter(isDefined).map(recurse).filter(Boolean));
+	else if (isAggregateError(error)) setErrorProperty$1(error, "errors", []);
+	else if (error.errors !== void 0) deleteAggregateErrors(error);
+};
+const isDefined = (error) => error !== void 0;
+const isAggregateError = (error) => "AggregateError" in globalThis && (error.name === "AggregateError" || error instanceof AggregateError);
+const deleteAggregateErrors = (error) => {
+	delete error.errors;
+	if (error.errors !== void 0) setErrorProperty$1(error, "errors", []);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/cause.js
+const normalizeCause = (error, recurse) => {
+	if (!("cause" in error)) return;
+	const cause = error.cause === void 0 ? error.cause : recurse(error.cause);
+	if (cause === void 0) delete error.cause;
+	else setErrorProperty$1(error, "cause", cause);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/modifiable.js
+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 !== void 0 && !descriptor.configurable;
+};
+const isThrowingProp = (error, propName) => {
+	try {
+		error[propName];
+		return false;
+	} catch {
+		return true;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/stack.js
+const setStack = (error) => {
+	setErrorProperty$1(error, "stack", getStack$3(error.message, error.name));
+};
+const getStack$3 = (message = "", name = "Error") => {
+	const { stack } = new (getErrorClass(name))(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;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/copy.js
+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;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/object.js
+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 === void 0) 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(object);
+	}
+};
+const safeStringify = (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 !== void 0) setErrorProperty$1(error, propName, propValue);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/string.js
+const stringifyError = (value) => {
+	try {
+		const error = new Error(String(value));
+		setStack(error);
+		return error;
+	} catch (error_) {
+		return error_;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/main.js
+const { toString: objectToString } = Object.prototype;
+const createError = (value) => {
+	if (isErrorPlainObj(value)) return objectifyError(value);
+	if (!main_default$7(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);
+
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/main.js
+const normalizeException = (error, { shallow = false } = {}) => recurseException(error, [], shallow);
+var main_default$6 = normalizeException;
+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;
+	setErrorProperty$1(error, "name", isDefinedString$1(prototypeName) ? prototypeName : error.constructor.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 !== "";
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/args.js
+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";
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/enum.js
+const setNonEnumProp$1 = (error, propName, value) => {
+	Object.defineProperty(error, propName, {
+		value,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/prototype.js
+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 : void 0;
+const getConstructorName = (prototype) => typeof prototype.constructor === "function" && isDefinedString(prototype.constructor.name) ? prototype.constructor.name : void 0;
+const isDefinedString = (value) => typeof value === "string" && value !== "";
+const deleteOwnProperty = (error, propName) => {
+	if (Object.hasOwn(error, propName)) delete error[propName];
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/stack.js
+const updateStack$1 = (error, currentName) => {
+	if (!shouldUpdateStack(error, currentName)) return;
+	setNonEnumProp$1(error, "stack", getStack$2(error, currentName));
+};
+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 [fromA, to] = getReplacers$1(currentName, name).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]
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/main.js
+const setErrorClass = (error, ErrorClass, currentName) => {
+	const errorA = main_default$6(error);
+	const currentNameA = normalizeArgs$1(errorA, ErrorClass, currentName);
+	updatePrototype(errorA, ErrorClass);
+	updateStack$1(errorA, currentNameA);
+	return errorA;
+};
+var main_default$5 = setErrorClass;
+
+//#endregion
+//#region ../../node_modules/.pnpm/redefine-property@3.0.1/node_modules/redefine-property/build/src/merge.js
+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);
+	return {
+		...mergeValue(newDescriptor, currentDescriptor, writable),
+		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 !== void 0 || set !== void 0;
+const mergeDescriptor = (newValue, currentValue, defaultValue) => newValue ?? currentValue ?? defaultValue;
+
+//#endregion
+//#region ../../node_modules/.pnpm/redefine-property@3.0.1/node_modules/redefine-property/build/src/normalize.js
+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 !== void 0) throw new TypeError(`Descriptor property "value" and "${propName}" must not both be defined: ${getSet}`);
+};
+const validateFunction = (propValue, propName) => {
+	if (propValue !== void 0 && typeof propValue !== "function") throw new TypeError(`Descriptor property "${propName}" must be a function: ${propValue}`);
+};
+const validateBoolean = (propValue, propName) => {
+	if (propValue !== void 0 && typeof propValue !== "boolean") throw new TypeError(`Descriptor property "${propName}" must be a boolean: ${propValue}`);
+};
+const validateUnknownProps = (unknownProps) => {
+	const [unknownProp] = Object.keys(unknownProps);
+	if (unknownProp !== void 0) throw new TypeError(`Unknown descriptor property "${unknownProp}": ${unknownProps[unknownProp]}`);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/redefine-property@3.0.1/node_modules/redefine-property/build/src/main.js
+const redefineProperty = (input, key, newDescriptor) => {
+	setProperty(input, key, mergeDescriptors(normalizeInput(input, key, newDescriptor), getCurrentDescriptor(input, key)));
+	return input;
+};
+var main_default$4 = redefineProperty;
+const getCurrentDescriptor = (input, key) => {
+	const descriptor = Object.getOwnPropertyDescriptor(input, key);
+	if (descriptor !== void 0) 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 {}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/assign.js
+const assignProp = (error, propName, propValue) => {
+	if (propValue !== void 0) return setProp(error, propName, propValue);
+	try {
+		delete error[propName];
+	} catch {}
+	if (error[propName] !== void 0) return setProp(error, propName);
+};
+const setProp = (error, propName, propValue) => {
+	main_default$4(error, propName, {
+		value: propValue,
+		...getNonEnum(propName)
+	});
+};
+const getNonEnum = (propName) => typeof propName === "string" && propName.startsWith("_") ? { enumerable: false } : {};
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/options.js
+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 === void 0) 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) || main_default$7(value);
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/skip.js
+const shouldSkipProp = ({ error, props, propName, soft }) => isIgnoredPropName(propName) || !isEnum.call(props, propName) || soft && error[propName] !== void 0;
+const isIgnoredPropName = (propName) => propName in CHECK_ERROR || IGNORED_PROPS.has(propName);
+const CHECK_ERROR = /* @__PURE__ */ new Error("check");
+const IGNORED_PROPS = new Set([
+	"prototype",
+	"errors",
+	"cause"
+]);
+const { propertyIsEnumerable: isEnum } = Object.prototype;
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/main.js
+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;
+};
+var main_default$3 = setErrorProps;
+const setErrorProp = ({ error, props, propName, soft }) => {
+	if (!shouldSkipProp({
+		error,
+		props,
+		propName,
+		soft
+	})) assignProp(error, propName, props[propName]);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/set.js
+const setErrorProperty = (error, propName, value) => {
+	Object.defineProperty(error, propName, {
+		value,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/aggregate.js
+const mergeAggregateCauses = (parent, recurse) => {
+	if (parent.errors === void 0) return;
+	setErrorProperty(parent, "errors", parent.errors.map((error) => recurse(error).error).filter(Boolean));
+};
+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 !== void 0) setErrorProperty(target, "errors", source.errors);
+};
+const hasErrors = (targetOrSource) => targetOrSource.errors !== void 0 && targetOrSource.errors.length !== 0;
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-message@3.0.1/node_modules/set-error-message/build/src/args.js
+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;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-message@3.0.1/node_modules/set-error-message/build/src/stack.js
+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 [fromA, to] = getReplacers(name, newMessage, currentMessage).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}`;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/set-error-message@3.0.1/node_modules/set-error-message/build/src/main.js
+const setErrorMessage = (error, newMessage, currentMessage) => {
+	const errorA = main_default$6(error);
+	const currentMessageA = normalizeArgs(errorA, newMessage, currentMessage);
+	setNonEnumProp(errorA, "message", newMessage);
+	updateStack(errorA, newMessage, currentMessageA);
+	return errorA;
+};
+var main_default$2 = setErrorMessage;
+const updateStack = (error, newMessage, currentMessage) => {
+	if (newMessage === currentMessage || !stackIncludesMessage()) return;
+	setNonEnumProp(error, "stack", getStack$1(error, newMessage, currentMessage));
+};
+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
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/wrap-error-message@3.0.1/node_modules/wrap-error-message/build/src/main.js
+const wrapErrorMessage = (error, newMessage, oldMessage) => {
+	if (typeof newMessage !== "string") throw new TypeError(`Second argument must be a message string: ${newMessage}`);
+	const errorA = main_default$6(error);
+	return main_default$2(errorA, getMessage(newMessage, errorA.message), oldMessage);
+};
+var main_default$1 = wrapErrorMessage;
+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";
+
+//#endregion
+//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/message.js
+const mergeMessage = ({ parent, child, target, stackError }) => {
+	const parentMessage = parent.message;
+	const stackErrorMessage = stackError.message;
+	target.message = child.message;
+	return main_default$1(target, parentMessage, stackErrorMessage);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/stack.js
+const hasStack = (error, stack) => getStack(error) === stack;
+const getStack = (error) => typeof error === "object" && error !== null ? error.stack : void 0;
+const mergeStack = ({ wrap, target, source, childHasStack }) => {
+	if (wrap === childHasStack) return target;
+	setErrorProperty(target, "stack", source.stack);
+	return source;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/wrap.js
+const getWrap = (parent) => {
+	const { wrap, name } = parent;
+	if (typeof wrap !== "boolean") return name === "Error";
+	if (Object.hasOwn(parent, "wrap")) delete parent.wrap;
+	return wrap;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/main.js
+const mergeErrorCause = (error) => mergeError(error, []).error;
+var main_default = mergeErrorCause;
+const mergeError = (error, parents) => {
+	if (parents.includes(error)) return {};
+	const recurse = (innerError) => mergeError(innerError, [...parents, error]);
+	const stack = getStack(error);
+	const errorA = main_default$6(error, { shallow: true });
+	const parentHasStack = hasStack(errorA, stack);
+	mergeAggregateCauses(errorA, recurse);
+	const { parent: errorB, childHasStack } = mergeCause(errorA, recurse);
+	return {
+		error: errorB,
+		errorHasStack: parentHasStack || childHasStack
+	};
+};
+const mergeCause = (parent, recurse) => {
+	const wrap = getWrap(parent);
+	if (parent.cause === void 0) return {
+		parent,
+		childHasStack: false
+	};
+	const { error: child, errorHasStack: childHasStack } = recurse(parent.cause);
+	delete parent.cause;
+	return {
+		parent: mergeChild({
+			parent,
+			child,
+			childHasStack,
+			wrap
+		}),
+		childHasStack
+	};
+};
+const mergeChild = ({ parent, child, childHasStack, wrap }) => {
+	if (child === void 0) return parent;
+	const [target, source] = wrap ? [child, parent] : [parent, child];
+	const stackError = mergeStack({
+		wrap,
+		target,
+		source,
+		childHasStack
+	});
+	const targetB = mergeMessage({
+		parent,
+		child,
+		target: main_default$5(target, target.constructor, stackError.name),
+		stackError
+	});
+	mergeAggregateErrors({
+		target: targetB,
+		source,
+		parent,
+		child
+	});
+	return main_default$3(targetB, source, { soft: !wrap });
+};
+
+//#endregion
+export { main_default$1 as n, main_default as t };