resultar 3.4.0 → 3.5.1

package/dist/index.js

@@ -253,7 +253,8 @@ var ResultNamespace = class {
 	}
 	static validateAll(resultListOrItems, f) {
 		if (f === void 0) return combineResultListWithAllErrors(resultListOrItems);
-		return combineResultListWithAllErrors(Array.from(resultListOrItems, f));
+		const resultList = Array.from(resultListOrItems, f);
+		return combineResultListWithAllErrors(resultList);
 	}
 	static zip(left, right) {
 		return combineResultList([left, right]);
@@ -667,6 +668,253 @@ const runSync = (result) => result.unwrapOrThrow();
 /** Compatibility alias. Prefer `tryResult` in new code. */
 const tryCatch = tryResult;
 //#endregion
+//#region src/redacted.ts
+const redactedValues = /* @__PURE__ */ new WeakMap();
+const formatRedacted = (label) => label === void 0 ? "<redacted>" : `<redacted:${label}>`;
+var RedactedValue = class {
+	__resultarRedacted = true;
+	label;
+	/**
+	* Stores a sensitive value behind a redacted string wrapper.
+	*/
+	constructor(value, label) {
+		this.label = label;
+		redactedValues.set(this, value);
+	}
+	/**
+	* Serializes to the redacted placeholder.
+	*/
+	toJSON() {
+		return this.toString();
+	}
+	/**
+	* Converts to the redacted placeholder.
+	*/
+	toString() {
+		return formatRedacted(this.label);
+	}
+};
+/**
+* Wraps a sensitive value so tagged-error messages and JSON output show only a placeholder.
+*/
+const redact = (value, label) => new RedactedValue(value, label);
+/**
+* Checks whether a value was created by `redact`.
+*/
+const isRedacted = (value) => typeof value === "object" && value !== null && redactedValues.has(value);
+/**
+* Returns the original sensitive value from a Redacted wrapper.
+*/
+const revealRedacted = (value) => redactedValues.get(value);
+/**
+* Converts a Redacted wrapper to its placeholder string.
+*/
+const stringifyRedacted = (value) => value.toString();
+//#endregion
+//#region src/tagged-error.ts
+const defaultBaseError = Error;
+const defaultMessageTemplate = "$message";
+const nativeError = Error;
+const templateVariableMatcher = /\$(?<name>[a-zA-Z_][a-zA-Z0-9_]*)/gu;
+const reservedTemplateVariables = /* @__PURE__ */ new Set([
+	"_tag",
+	"cause",
+	"fingerprint",
+	"message",
+	"messageTemplate",
+	"name",
+	"stack"
+]);
+function isError(value) {
+	return nativeError.isError?.(value) ?? value instanceof Error;
+}
+const stringifyDirectTemplateValue = String;
+const stringifySymbolTemplateValue = (value) => {
+	const symbol = value;
+	return symbol.description ?? symbol.toString();
+};
+const stringifyFunctionTemplateValue = (value) => value.name;
+const stringifyObjectTemplateValue = (value) => JSON.stringify(value) ?? Object.prototype.toString.call(value);
+const templateValueStringifiers = {
+	bigint: stringifyDirectTemplateValue,
+	boolean: stringifyDirectTemplateValue,
+	function: stringifyFunctionTemplateValue,
+	number: stringifyDirectTemplateValue,
+	object: stringifyObjectTemplateValue,
+	string: stringifyDirectTemplateValue,
+	symbol: stringifySymbolTemplateValue
+};
+const stringifyTemplateValue = (value) => isRedacted(value) ? stringifyRedacted(value) : templateValueStringifiers[typeof value](value);
+const compileMessageInterpolator = (template) => (values) => template.replaceAll(templateVariableMatcher, (variable, key) => {
+	const value = values?.[key];
+	return value === void 0 ? variable : stringifyTemplateValue(value);
+});
+const getTemplateVariableNames = (template) => {
+	templateVariableMatcher.lastIndex = 0;
+	return [...template.matchAll(templateVariableMatcher)].map((match) => String(match[1]));
+};
+const assertNoReservedTemplateVariables = (tag, template) => {
+	if (template === defaultMessageTemplate) return;
+	const reservedVariables = getTemplateVariableNames(template).filter((variable) => reservedTemplateVariables.has(variable));
+	if (reservedVariables.length > 0) throw new Error(`createTaggedError(${tag}): reserved template variable $${reservedVariables[0]} is not allowed`);
+};
+const getErrorOptions = (cause) => cause === void 0 ? {} : { cause };
+const assignReadonly = (target, key, value) => {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: false
+	});
+};
+const serializeTaggedValue = (value) => isRedacted(value) ? stringifyRedacted(value) : value;
+const serializeCause = (cause, seen = /* @__PURE__ */ new Set()) => {
+	if (!isError(cause)) return serializeTaggedValue(cause);
+	if (seen.has(cause)) return {
+		cause: "[Circular]",
+		message: cause.message,
+		name: cause.name,
+		stack: cause.stack
+	};
+	seen.add(cause);
+	const json = {
+		message: cause.message,
+		name: cause.name,
+		stack: cause.stack
+	};
+	if (cause.cause !== void 0) json["cause"] = serializeCause(cause.cause, seen);
+	return json;
+};
+/**
+* Finds the first cause in an Error cause chain that is an instance of `ErrorClass`.
+*/
+const findCause = (error, ErrorClass) => {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (isError(current)) {
+		if (seen.has(current)) break;
+		seen.add(current);
+		if (current instanceof ErrorClass) return current;
+		current = current.cause;
+	}
+};
+/**
+* Creates an Error class with a stable `_tag`, typed template props, cause support, and JSON output.
+*
+* Prefer tagged errors for domain failures that travel through Resultar error channels.
+*
+* @example
+* ```ts
+* class UserNotFoundError extends createTaggedError({
+*   name: "UserNotFoundError",
+*   message: "User $id was not found",
+* }) {}
+* ```
+*/
+function createTaggedError(options) {
+	const BaseError = options.extends ?? defaultBaseError;
+	const messageTemplate = options.message ?? defaultMessageTemplate;
+	assertNoReservedTemplateVariables(options.name, messageTemplate);
+	const interpolate = compileMessageInterpolator(messageTemplate);
+	class GeneratedTaggedError extends BaseError {
+		static tag = options.name;
+		_tag = options.name;
+		fingerprint = [options.name, messageTemplate];
+		messageTemplate = messageTemplate;
+		constructor(props) {
+			const message = interpolate(props);
+			super(message, getErrorOptions(props?.cause));
+			this.name = options.name;
+			if (props) {
+				for (const [key, value] of Object.entries(props)) if (!reservedTemplateVariables.has(key)) assignReadonly(this, key, value);
+			}
+		}
+		/**
+		* Narrows a value to this tagged error class.
+		*/
+		static is(value) {
+			return value instanceof this;
+		}
+		/**
+		* Creates an Err containing this tagged error.
+		*/
+		static err(...args) {
+			return err(new this(...args));
+		}
+		/**
+		* Finds a matching cause in this error's cause chain.
+		*/
+		findCause(ErrorClass) {
+			return findCause(this, ErrorClass);
+		}
+		/**
+		* Serializes the tagged error, metadata, and cause chain.
+		*/
+		toJSON() {
+			const json = {
+				_tag: this._tag,
+				fingerprint: this.fingerprint,
+				message: this.message,
+				messageTemplate: this.messageTemplate,
+				name: this.name
+			};
+			if (this.cause !== void 0) json["cause"] = serializeCause(this.cause);
+			for (const [key, value] of Object.entries(this)) if (!(key in json) && key !== "cause" && key !== "stack") json[key] = serializeTaggedValue(value);
+			return json;
+		}
+	}
+	return GeneratedTaggedError;
+}
+/**
+* Creates a small tagged-union factory with member constructors, `$is`, and `$match`.
+*/
+const taggedEnum = () => {
+	return new Proxy({
+		$is(tag, value) {
+			return typeof value === "object" && value !== null && "_tag" in value && value._tag === tag;
+		},
+		$match(value, handlers) {
+			const handler = handlers[value._tag];
+			if (handler === void 0) throw new Error(`No tagged enum handler for ${String(value._tag)}`);
+			return handler(value);
+		}
+	}, { get(base, property, receiver) {
+		if (property in base) return Reflect.get(base, property, receiver);
+		if (typeof property !== "string") return;
+		return (props) => {
+			const value = { _tag: property };
+			if (props !== void 0) {
+				for (const [key, propValue] of Object.entries(props)) if (key !== "_tag") value[key] = propValue;
+			}
+			return Object.freeze(value);
+		};
+	} });
+};
+/**
+* Matches an Error by tagged `_tag`, with optional native `Error` fallback.
+*
+* Throws the original error when no handler matches.
+*/
+const matchError = (error, handlers) => {
+	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
+		const handler = handlers[error._tag];
+		return handler(error);
+	}
+	if (handlers.Error) return handlers.Error(error);
+	throw error;
+};
+/**
+* Matches an Error by tagged `_tag`, then native `Error`, then the provided fallback.
+*/
+const matchErrorPartial = (error, handlers, fallback) => {
+	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
+		const handler = handlers[error._tag];
+		if (handler) return handler(error);
+	}
+	if (handlers.Error) return handlers.Error(error);
+	return fallback(error);
+};
+//#endregion
 //#region src/result-async.ts
 function isTryResultAsyncOptions(input) {
 	return typeof input === "object" && input !== null && "try" in input;
@@ -782,6 +1030,79 @@ const runConcurrentResultAsyncItems = (options) => Promise.try(async () => {
 });
 const createResultAsyncRetryAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync retry aborted") : new AbortError("ResultAsync retry aborted", { cause: signal.reason });
 const createResultAsyncResourceAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync resource scope aborted") : new AbortError("ResultAsync resource scope aborted", { cause: signal.reason });
+const createResultAsyncCallbackAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync callback aborted") : new AbortError("ResultAsync callback aborted", { cause: signal.reason });
+const emptyResultAsyncCallbackCleanup = () => void 0;
+const callResultAsyncCallbackCleanup = (cleanup) => {
+	try {
+		cleanup();
+	} catch {}
+};
+const normalizeResultAsyncCallbackUnexpectedError = (error) => isError(error) ? error : new Error("ResultAsync callback error mapper threw a non-Error value", { cause: error });
+const completeResultAsyncCallback = (completion) => {
+	if ("error" in completion.settlement) {
+		completion.rejectResult(normalizeResultAsyncCallbackUnexpectedError(completion.settlement.error));
+		return;
+	}
+	completion.resolveResult(completion.settlement.result);
+};
+const fromResultAsyncCallback = (options) => {
+	const signal = options.signal ?? new AbortController().signal;
+	return new ResultAsync(new Promise((resolveResult, rejectResult) => {
+		if (signal.aborted) {
+			resolveResult(Result.err(createResultAsyncCallbackAbortError(signal)));
+			return;
+		}
+		let cleanup = emptyResultAsyncCallbackCleanup;
+		let settlement = void 0;
+		let subscribed = false;
+		const finalize = () => {
+			if (!subscribed) return;
+			const completed = settlement;
+			if (completed === void 0) return;
+			signal.removeEventListener("abort", abort);
+			callResultAsyncCallbackCleanup(cleanup);
+			completeResultAsyncCallback({
+				rejectResult,
+				resolveResult,
+				settlement: completed
+			});
+		};
+		const settle = (result) => {
+			if (settlement !== void 0) return;
+			settlement = { result };
+			finalize();
+		};
+		const rejectUnexpected = (error) => {
+			settlement = { error };
+			finalize();
+		};
+		const abort = () => {
+			settle(Result.err(createResultAsyncCallbackAbortError(signal)));
+		};
+		const context = {
+			reject: (cause) => {
+				if (settlement !== void 0) return;
+				try {
+					settle(Result.err(options.catch(cause)));
+				} catch (error) {
+					rejectUnexpected(error);
+				}
+			},
+			resolve: (value) => {
+				settle(Result.ok(value));
+			},
+			signal
+		};
+		signal.addEventListener("abort", abort);
+		try {
+			cleanup = options.subscribe(context) ?? emptyResultAsyncCallbackCleanup;
+		} catch (error) {
+			context.reject(error);
+		}
+		subscribed = true;
+		finalize();
+	}));
+};
 const validateResultAsyncRetryTimes = (times) => {
 	if (!Number.isInteger(times) || times < 0) throw createIllegalArgumentException("ResultAsync retry times must be a non-negative integer");
 };
@@ -1077,14 +1398,16 @@ const toResultAsync = (result) => {
 };
 const ifResultAsync = (condition, options) => {
 	return new ResultAsync(Promise.try(async () => {
-		return await toResultAsync(resolveResultAsyncBooleanCondition(condition) ? options.onTrue() : options.onFalse());
+		const result = resolveResultAsyncBooleanCondition(condition) ? options.onTrue() : options.onFalse();
+		return await toResultAsync(result);
 	}));
 };
 const ifResultAsyncWithCondition = (condition, options) => {
 	return new ResultAsync(Promise.try(async () => {
 		const conditionResult = await toResultAsync(condition);
 		if (conditionResult.isErr()) return Result.err(conditionResult.error);
-		return await toResultAsync(conditionResult.value ? options.onTrue() : options.onFalse());
+		const result = conditionResult.value ? options.onTrue() : options.onFalse();
+		return await toResultAsync(result);
 	}));
 };
 const whenResultAsync = (condition, body) => {
@@ -1175,7 +1498,7 @@ var DisposableResultAsync = class {
 * but operating in an asynchronous context.
 *
 * The class includes methods for:
-* - Creating ResultAsync instances (okAsync, errAsync, fromPromise)
+* - Creating ResultAsync instances (okAsync, errAsync, fromPromise, fromCallback)
 * - Transforming values (map, mapErr)
 * - Chaining operations (andThen, orElse)
 * - Error handling (tapError)
@@ -1198,16 +1521,28 @@ var ResultAsync = class ResultAsync extends Pipeable {
 		return new ResultAsync(Promise.resolve(err(error)));
 	}
 	static tryCatch(fn, errorFn) {
-		return new ResultAsync((typeof fn === "function" ? Promise.try(fn) : fn).then((value) => ok(value)).catch((error) => {
+		const newPromise = (typeof fn === "function" ? Promise.try(fn) : fn).then((value) => ok(value)).catch((error) => {
 			if (errorFn) return err(errorFn(error));
 			return err(error);
-		}));
+		});
+		return new ResultAsync(newPromise);
 	}
 	static fromSafePromise(promise) {
-		return new ResultAsync(promise.then((value) => ok(value)));
+		const newPromise = promise.then((value) => ok(value));
+		return new ResultAsync(newPromise);
 	}
 	static fromPromise(promise, errorFn) {
-		return new ResultAsync(promise.then((value) => ok(value)).catch((error) => err(errorFn(error))));
+		const newPromise = promise.then((value) => ok(value)).catch((error) => err(errorFn(error)));
+		return new ResultAsync(newPromise);
+	}
+	/**
+	* Adapts a callback or subscription API into a cancellable ResultAsync.
+	*
+	* The returned cleanup function runs once after resolve, reject, cancellation, or synchronous
+	* subscription failure. Cleanup errors are ignored.
+	*/
+	static fromCallback(options) {
+		return fromResultAsyncCallback(options);
 	}
 	static combine(input) {
 		if (Array.isArray(input)) return combineResultAsyncList(input);
@@ -1283,7 +1618,7 @@ var ResultAsync = class ResultAsync extends Pipeable {
 	* Handlers receive the settled Result and a handle to the still-running opposite task.
 	*/
 	static raceWith(left, right, handlers) {
-		return new ResultAsync(new Promise((resolve) => {
+		const promise = new Promise((resolve) => {
 			const leftTask = startRaceTask(left, 0);
 			const rightTask = startRaceTask(right, 1);
 			const leftHandle = createRaceHandle(leftTask);
@@ -1305,21 +1640,23 @@ var ResultAsync = class ResultAsync extends Pipeable {
 					resolve(handledResult);
 				});
 			});
-		}));
+		});
+		return new ResultAsync(promise);
 	}
 	/**
 	* Runs a cooperative ResultAsync task with a typed timeout error.
 	*/
 	static timeout(task, options) {
 		const timeoutTask = (signal) => {
-			return new ResultAsync(new Promise((resolve) => {
+			const promise = new Promise((resolve) => {
 				const timeout = setTimeout(() => {
 					resolve(Result.err(options.onTimeout()));
 				}, options.timeoutMs);
 				signal.addEventListener("abort", () => {
 					clearTimeout(timeout);
 				});
-			}));
+			});
+			return new ResultAsync(promise);
 		};
 		return ResultAsync.raceWith(task, timeoutTask, {
 			onLeftDone: (result, timeoutHandle) => {
@@ -1650,6 +1987,10 @@ const okAsync = ResultAsync.okAsync;
 */
 const errAsync = ResultAsync.errAsync;
 /**
+* Adapts a callback or subscription API into a cancellable ResultAsync.
+*/
+const fromCallback = ResultAsync.fromCallback;
+/**
 * Converts an existing promise into a ResultAsync and maps rejection into a typed Err.
 */
 const fromPromise = ResultAsync.fromPromise;
@@ -1685,253 +2026,4 @@ const runPromise = (result) => result.unwrapOrThrow();
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
 const tryCatchAsync = tryResultAsync;
 //#endregion
-//#region src/redacted.ts
-const redactedValues = /* @__PURE__ */ new WeakMap();
-const formatRedacted = (label) => label === void 0 ? "<redacted>" : `<redacted:${label}>`;
-var RedactedValue = class {
-	__resultarRedacted = true;
-	label;
-	/**
-	* Stores a sensitive value behind a redacted string wrapper.
-	*/
-	constructor(value, label) {
-		this.label = label;
-		redactedValues.set(this, value);
-	}
-	/**
-	* Serializes to the redacted placeholder.
-	*/
-	toJSON() {
-		return this.toString();
-	}
-	/**
-	* Converts to the redacted placeholder.
-	*/
-	toString() {
-		return formatRedacted(this.label);
-	}
-};
-/**
-* Wraps a sensitive value so tagged-error messages and JSON output show only a placeholder.
-*/
-const redact = (value, label) => new RedactedValue(value, label);
-/**
-* Checks whether a value was created by `redact`.
-*/
-const isRedacted = (value) => typeof value === "object" && value !== null && redactedValues.has(value);
-/**
-* Returns the original sensitive value from a Redacted wrapper.
-*/
-const revealRedacted = (value) => redactedValues.get(value);
-/**
-* Converts a Redacted wrapper to its placeholder string.
-*/
-const stringifyRedacted = (value) => value.toString();
-//#endregion
-//#region src/tagged-error.ts
-const defaultBaseError = Error;
-const defaultMessageTemplate = "$message";
-const nativeError = Error;
-const templateVariableMatcher = /\$(?<name>[a-zA-Z_][a-zA-Z0-9_]*)/gu;
-const reservedTemplateVariables = new Set([
-	"_tag",
-	"cause",
-	"fingerprint",
-	"message",
-	"messageTemplate",
-	"name",
-	"stack"
-]);
-function isError(value) {
-	return nativeError.isError?.(value) ?? value instanceof Error;
-}
-const stringifyDirectTemplateValue = String;
-const stringifySymbolTemplateValue = (value) => {
-	const symbol = value;
-	return symbol.description ?? symbol.toString();
-};
-const stringifyFunctionTemplateValue = (value) => value.name;
-const stringifyObjectTemplateValue = (value) => JSON.stringify(value) ?? Object.prototype.toString.call(value);
-const templateValueStringifiers = {
-	bigint: stringifyDirectTemplateValue,
-	boolean: stringifyDirectTemplateValue,
-	function: stringifyFunctionTemplateValue,
-	number: stringifyDirectTemplateValue,
-	object: stringifyObjectTemplateValue,
-	string: stringifyDirectTemplateValue,
-	symbol: stringifySymbolTemplateValue
-};
-const stringifyTemplateValue = (value) => isRedacted(value) ? stringifyRedacted(value) : templateValueStringifiers[typeof value](value);
-const compileMessageInterpolator = (template) => (values) => template.replaceAll(templateVariableMatcher, (variable, key) => {
-	const value = values?.[key];
-	return value === void 0 ? variable : stringifyTemplateValue(value);
-});
-const getTemplateVariableNames = (template) => {
-	templateVariableMatcher.lastIndex = 0;
-	return [...template.matchAll(templateVariableMatcher)].map((match) => String(match.groups?.["name"]));
-};
-const assertNoReservedTemplateVariables = (tag, template) => {
-	if (template === defaultMessageTemplate) return;
-	const reservedVariables = getTemplateVariableNames(template).filter((variable) => reservedTemplateVariables.has(variable));
-	if (reservedVariables.length > 0) throw new Error(`createTaggedError(${tag}): reserved template variable $${reservedVariables[0]} is not allowed`);
-};
-const getErrorOptions = (cause) => cause === void 0 ? {} : { cause };
-const assignReadonly = (target, key, value) => {
-	Object.defineProperty(target, key, {
-		configurable: true,
-		enumerable: true,
-		value,
-		writable: false
-	});
-};
-const serializeTaggedValue = (value) => isRedacted(value) ? stringifyRedacted(value) : value;
-const serializeCause = (cause, seen = /* @__PURE__ */ new Set()) => {
-	if (!isError(cause)) return serializeTaggedValue(cause);
-	if (seen.has(cause)) return {
-		cause: "[Circular]",
-		message: cause.message,
-		name: cause.name,
-		stack: cause.stack
-	};
-	seen.add(cause);
-	const json = {
-		message: cause.message,
-		name: cause.name,
-		stack: cause.stack
-	};
-	if (cause.cause !== void 0) json["cause"] = serializeCause(cause.cause, seen);
-	return json;
-};
-/**
-* Finds the first cause in an Error cause chain that is an instance of `ErrorClass`.
-*/
-const findCause = (error, ErrorClass) => {
-	const seen = /* @__PURE__ */ new Set();
-	let current = error;
-	while (isError(current)) {
-		if (seen.has(current)) break;
-		seen.add(current);
-		if (current instanceof ErrorClass) return current;
-		current = current.cause;
-	}
-};
-/**
-* Creates an Error class with a stable `_tag`, typed template props, cause support, and JSON output.
-*
-* Prefer tagged errors for domain failures that travel through Resultar error channels.
-*
-* @example
-* ```ts
-* class UserNotFoundError extends createTaggedError({
-*   name: "UserNotFoundError",
-*   message: "User $id was not found",
-* }) {}
-* ```
-*/
-function createTaggedError(options) {
-	const BaseError = options.extends ?? defaultBaseError;
-	const messageTemplate = options.message ?? defaultMessageTemplate;
-	assertNoReservedTemplateVariables(options.name, messageTemplate);
-	const interpolate = compileMessageInterpolator(messageTemplate);
-	class GeneratedTaggedError extends BaseError {
-		static tag = options.name;
-		_tag = options.name;
-		fingerprint = [options.name, messageTemplate];
-		messageTemplate = messageTemplate;
-		constructor(props) {
-			const message = interpolate(props);
-			super(message, getErrorOptions(props?.cause));
-			this.name = options.name;
-			if (props) {
-				for (const [key, value] of Object.entries(props)) if (!reservedTemplateVariables.has(key)) assignReadonly(this, key, value);
-			}
-		}
-		/**
-		* Narrows a value to this tagged error class.
-		*/
-		static is(value) {
-			return value instanceof this;
-		}
-		/**
-		* Creates an Err containing this tagged error.
-		*/
-		static err(...args) {
-			return err(new this(...args));
-		}
-		/**
-		* Finds a matching cause in this error's cause chain.
-		*/
-		findCause(ErrorClass) {
-			return findCause(this, ErrorClass);
-		}
-		/**
-		* Serializes the tagged error, metadata, and cause chain.
-		*/
-		toJSON() {
-			const json = {
-				_tag: this._tag,
-				fingerprint: this.fingerprint,
-				message: this.message,
-				messageTemplate: this.messageTemplate,
-				name: this.name
-			};
-			if (this.cause !== void 0) json["cause"] = serializeCause(this.cause);
-			for (const [key, value] of Object.entries(this)) if (!(key in json) && key !== "cause" && key !== "stack") json[key] = serializeTaggedValue(value);
-			return json;
-		}
-	}
-	return GeneratedTaggedError;
-}
-/**
-* Creates a small tagged-union factory with member constructors, `$is`, and `$match`.
-*/
-const taggedEnum = () => {
-	return new Proxy({
-		$is(tag, value) {
-			return typeof value === "object" && value !== null && "_tag" in value && value._tag === tag;
-		},
-		$match(value, handlers) {
-			const handler = handlers[value._tag];
-			if (handler === void 0) throw new Error(`No tagged enum handler for ${String(value._tag)}`);
-			return handler(value);
-		}
-	}, { get(base, property, receiver) {
-		if (property in base) return Reflect.get(base, property, receiver);
-		if (typeof property !== "string") return;
-		return (props) => {
-			const value = { _tag: property };
-			if (props !== void 0) {
-				for (const [key, propValue] of Object.entries(props)) if (key !== "_tag") value[key] = propValue;
-			}
-			return Object.freeze(value);
-		};
-	} });
-};
-/**
-* Matches an Error by tagged `_tag`, with optional native `Error` fallback.
-*
-* Throws the original error when no handler matches.
-*/
-const matchError = (error, handlers) => {
-	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
-		const handler = handlers[error._tag];
-		return handler(error);
-	}
-	if (handlers.Error) return handlers.Error(error);
-	throw error;
-};
-/**
-* Matches an Error by tagged `_tag`, then native `Error`, then the provided fallback.
-*/
-const matchErrorPartial = (error, handlers, fallback) => {
-	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
-		const handler = handlers[error._tag];
-		if (handler) return handler(error);
-	}
-	if (handlers.Error) return handlers.Error(error);
-	return fallback(error);
-};
-//#endregion
-export { AbortError, DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
-
-//# sourceMappingURL=index.js.map
+export { AbortError, DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };