resultar 2.0.0 → 3.0.0-alpha.1

package/dist/index.js

@@ -1,9 +1,994 @@
-import { _ as unit, a as fromSafePromise, c as tryCatchAsync, d as Result, f as err, g as tryCatch, h as safeTry, i as fromPromise, l as unitAsync, m as ok, n as ResultAsync, o as fromThrowableAsync, p as fromThrowable, r as errAsync, s as okAsync, t as DisposableResultAsync, u as DisposableResult } from "./result-async-CdlVdXgX.js";
+//#region src/pipe.ts
+const runPipe = (self, fns) => {
+	const first = fns[0];
+	if (!first) return self;
+	let input = first(self);
+	for (const fn of fns.slice(1)) input = fn(input);
+	return input;
+};
+var Pipeable = class {
+	pipe(...fns) {
+		return runPipe(this, fns);
+	}
+};
+//#endregion
+//#region src/result-async-adapter.ts
+let resultAsyncFactory = void 0;
+const registerResultAsyncFactory = (factory) => {
+	resultAsyncFactory = factory;
+};
+const createResultAsync = (promise) => {
+	if (resultAsyncFactory === void 0) throw new Error("ResultAsync is not registered");
+	return resultAsyncFactory(promise);
+};
+//#endregion
+//#region src/error.ts
+const defaultErrorConfig = { withStackTrace: false };
+const createResultarError = (message, result, config = defaultErrorConfig) => {
+	const data = result.isOk() ? {
+		type: "Ok",
+		value: result.value
+	} : {
+		type: "Err",
+		value: result.error
+	};
+	const maybeStack = config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0;
+	const error = {
+		name: "ResultarError",
+		data,
+		message
+	};
+	return maybeStack === void 0 ? error : Object.assign(error, { stack: maybeStack });
+};
+//#endregion
+//#region src/tagged-match.ts
+const isTaggedValue = (value) => typeof value === "object" && value !== null && "_tag" in value;
+const hasTag = (value, tag) => isTaggedValue(value) && value._tag === tag;
+const callTaggedHandler = (value, handlers) => {
+	if (!isTaggedValue(value)) return { matched: false };
+	const handler = handlers[value._tag];
+	if (handler === void 0) return { matched: false };
+	return {
+		matched: true,
+		value: handler(value)
+	};
+};
+const callErrorHandler = (error, handlers) => {
+	if (handlers.Error === void 0) return { matched: false };
+	return {
+		matched: true,
+		value: handlers.Error(error)
+	};
+};
+const callTaggedOrErrorHandler = (error, handlers) => {
+	const tagged = callTaggedHandler(error, handlers);
+	if (tagged.matched) return tagged;
+	return callErrorHandler(error, handlers);
+};
+const matchTaggedOr = (error, handlers, fallback) => {
+	const handled = callTaggedOrErrorHandler(error, handlers);
+	return handled.matched ? handled.value : fallback(error);
+};
+//#endregion
+//#region src/result.ts
+const combineResultList = (resultList) => {
+	const values = [];
+	for (const result of resultList) {
+		if (result.isErr()) return err(result.error);
+		values.push(result.value);
+	}
+	return ok(values);
+};
+const combineResultListWithAllErrors = (resultList) => {
+	let acc = ok([]);
+	for (const result of resultList) if (result.isErr() && acc.isErr()) acc.error.push(result.error);
+	else if (result.isErr() && acc.isOk()) acc = err([result.error]);
+	else if (result.isOk() && acc.isOk()) acc.value.push(result.value);
+	return acc;
+};
+const validateAllResultItems = (items, f) => {
+	return combineResultListWithAllErrors(Array.from(items, f));
+};
+const createEmptyResultsCollectionError = () => {
+	const error = /* @__PURE__ */ new Error("Received an empty collection of results");
+	error.name = "IllegalArgumentException";
+	return error;
+};
+const firstSuccessOfResultCandidates = (candidates) => {
+	let latestError = void 0;
+	let hasCandidates = false;
+	for (const candidate of candidates) {
+		hasCandidates = true;
+		const result = candidate();
+		if (result.isOk()) return result;
+		latestError = result;
+	}
+	if (!hasCandidates || latestError === void 0) throw createEmptyResultsCollectionError();
+	return latestError;
+};
+const loopResult = (initial, options) => {
+	let state = initial;
+	const values = [];
+	while (options.while(state)) {
+		const result = options.body(state);
+		if (result.isErr()) return err(result.error);
+		if (options.discard !== true) values.push(result.value);
+		state = options.step(state);
+	}
+	if (options.discard === true) return ok(void 0);
+	return ok(values);
+};
+const iterateResult = (initial, options) => {
+	let state = initial;
+	while (options.while(state)) {
+		const result = options.body(state);
+		if (result.isErr()) return err(result.error);
+		state = result.value;
+	}
+	return ok(state);
+};
+const forEachResult = (items, f, options) => {
+	const values = [];
+	let index = 0;
+	for (const item of items) {
+		const result = f(item, index);
+		if (result.isErr()) return err(result.error);
+		if (options?.discard !== true) values.push(result.value);
+		index += 1;
+	}
+	if (options?.discard === true) return ok(void 0);
+	return ok(values);
+};
+const resolveResultBooleanCondition = (condition) => typeof condition === "function" ? condition() : condition;
+const ifResult = (condition, options) => resolveResultBooleanCondition(condition) ? options.onTrue() : options.onFalse();
+const ifResultWithCondition = (condition, options) => {
+	if (condition.isErr()) return err(condition.error);
+	return ifResult(condition.value, options);
+};
+const whenResult = (condition, body) => {
+	if (resolveResultBooleanCondition(condition)) return body();
+	return ok(void 0);
+};
+const whenResultWithConditionByPredicate = (condition, body, predicate) => {
+	if (condition.isErr()) return err(condition.error);
+	return whenResult(predicate(condition.value), body);
+};
+const whenResultWithCondition = (condition, body) => whenResultWithConditionByPredicate(condition, body, (value) => value);
+const unlessResult = (condition, body) => whenResult(() => !resolveResultBooleanCondition(condition), body);
+const unlessResultWithCondition = (condition, body) => whenResultWithConditionByPredicate(condition, body, (value) => !value);
+const callSyncSideEffect = (effect) => {
+	try {
+		effect();
+	} catch {}
+};
+const getMatchErrorHandler = (input, fnErr) => {
+	if (typeof input !== "function") return input.error;
+	if (fnErr === void 0) throw new TypeError("Result.match requires an error handler");
+	return fnErr;
+};
+/**
+* Runtime namespace for Result constructors and static helpers.
+*/
+var ResultNamespace = class {
+	static [Symbol.hasInstance](value) {
+		return value instanceof Ok || value instanceof Err;
+	}
+	/**
+	* Creates a `Result` by running a function that might throw.
+	* If the function throws, the error will be caught and returned as an `Err`.
+	* If the function succeeds, the value will be wrapped in an `Ok`.
+	*
+	* Compatibility alias. Prefer the top-level `tryResult` helper in new code.
+	*
+	* @param fn - The function to execute, which might throw an error
+	* @param errorFn - Optional function to transform the thrown error before wrapping in `Err`
+	* @returns A `Result` containing either the function's return value or the caught error
+	*/
+	static tryCatch(fn, errorFn) {
+		try {
+			return ok(fn());
+		} catch (error) {
+			if (errorFn) return err(errorFn(error));
+			return err(error);
+		}
+	}
+	/**
+	* Wraps a function with a try catch, creating a new function with the same
+	* arguments but returning `Ok` if successful, `Err` if the function throws
+	*
+	* @param fn function to wrap with ok on success or err on failure
+	* @param errorFn when an error is thrown, this will wrap the error result if provided
+	*/
+	static fromThrowable(fn, errorFn) {
+		return (...args) => {
+			try {
+				return ok(fn(...args));
+			} catch (error) {
+				if (errorFn) return err(errorFn(error));
+				return err(error);
+			}
+		};
+	}
+	static ok(value) {
+		return ok(value);
+	}
+	/**
+	* Creates a new `Result` instance representing a successful operation with an undefined value.
+	*
+	* @return {Result<undefined, E>} A new `Result` instance with an undefined value.
+	*/
+	static unit() {
+		return unit();
+	}
+	static err(error) {
+		return err(error);
+	}
+	static combine(resultList) {
+		return combineResultList(resultList);
+	}
+	static combineWithAllErrors(resultList) {
+		return combineResultListWithAllErrors(resultList);
+	}
+	static validateAll(resultListOrItems, f) {
+		if (f === void 0) return combineResultListWithAllErrors(resultListOrItems);
+		return validateAllResultItems(resultListOrItems, f);
+	}
+	static zip(left, right) {
+		return combineResultList([left, right]);
+	}
+	static firstSuccessOf(candidates) {
+		return firstSuccessOfResultCandidates(candidates);
+	}
+	static if(condition, options) {
+		if (typeof condition === "boolean" || typeof condition === "function") return ifResult(condition, options);
+		return ifResultWithCondition(condition, options);
+	}
+	static when(condition, body) {
+		return whenResult(condition, body);
+	}
+	static whenResult(condition, body) {
+		return whenResultWithCondition(condition, body);
+	}
+	static unless(condition, body) {
+		return unlessResult(condition, body);
+	}
+	static unlessResult(condition, body) {
+		return unlessResultWithCondition(condition, body);
+	}
+	static loop(initial, options) {
+		return loopResult(initial, options);
+	}
+	static iterate(initial, options) {
+		return iterateResult(initial, options);
+	}
+	static forEach(items, f, options) {
+		return forEachResult(items, f, options);
+	}
+};
+const Result = ResultNamespace;
+var ResultVariant = class extends Pipeable {
+	filterOrElse(predicate, onFalse) {
+		return this.filterOrElseResult(predicate, onFalse);
+	}
+	if(fCondition) {
+		return { true: (fTrue) => ({ false: (fFalse) => this.branchResult(fCondition, fTrue, fFalse) }) };
+	}
+	orElse(f) {
+		return this.orElseResult(f);
+	}
+};
+var Ok = class extends ResultVariant {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	isOk() {
+		return true;
+	}
+	isErr() {
+		return false;
+	}
+	map(f) {
+		return ok(f(this.value));
+	}
+	as(value) {
+		return ok(value);
+	}
+	filterOrElseResult(predicate, onFalse) {
+		if (predicate(this.value)) return ok(this.value);
+		return err(onFalse(this.value));
+	}
+	mapErr(_fn) {
+		return ok(this.value);
+	}
+	andThen(f) {
+		return f(this.value);
+	}
+	orElseResult(_f) {
+		return ok(this.value);
+	}
+	catchTag(_tag, _f) {
+		return ok(this.value);
+	}
+	catchTags(_handlers) {
+		return ok(this.value);
+	}
+	branchResult(fCondition, fTrue, fFalse) {
+		return fCondition(this.value) ? fTrue(this.value) : fFalse(this.value);
+	}
+	asyncAndThen(f) {
+		return f(this.value);
+	}
+	asyncMap(f) {
+		return createResultAsync(Promise.resolve(f(this.value)).then((value) => ok(value)));
+	}
+	unwrapOr(_defaultValue) {
+		return this.value;
+	}
+	match(input, _fnErr) {
+		return (typeof input === "function" ? input : input.ok)(this.value);
+	}
+	matchTags(fnOk, _handlers) {
+		return fnOk(this.value);
+	}
+	matchTagsPartial(fnOk, _handlers, _fallback) {
+		return fnOk(this.value);
+	}
+	log(fn) {
+		callSyncSideEffect(() => {
+			fn(this.value, void 0);
+		});
+		return this;
+	}
+	tap(fn) {
+		callSyncSideEffect(() => {
+			fn(this.value);
+		});
+		return this;
+	}
+	tapError(_fn) {
+		return this;
+	}
+	toDisposable(f) {
+		return new DisposableResult(this, f);
+	}
+	unwrapOrThrow() {
+		return this.value;
+	}
+	_unsafeUnwrap(_config) {
+		return this.value;
+	}
+	_unsafeUnwrapErr(config) {
+		throw createResultarError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+	}
+	*[Symbol.iterator]() {
+		return this.value;
+	}
+	safeUnwrap() {
+		const { value } = this;
+		return (function* () {
+			return value;
+		})();
+	}
+};
+var Err = class extends ResultVariant {
+	error;
+	constructor(error) {
+		super();
+		this.error = error;
+	}
+	isOk() {
+		return false;
+	}
+	isErr() {
+		return true;
+	}
+	map(_f) {
+		return err(this.error);
+	}
+	as(_value) {
+		return err(this.error);
+	}
+	filterOrElseResult(_predicate, _onFalse) {
+		return err(this.error);
+	}
+	mapErr(fn) {
+		return err(fn(this.error));
+	}
+	andThen(_f) {
+		return err(this.error);
+	}
+	orElseResult(f) {
+		return f(this.error);
+	}
+	branchResult(_fCondition, _fTrue, _fFalse) {
+		return err(this.error);
+	}
+	catchTag(tag, f) {
+		if (hasTag(this.error, tag)) return f(this.error);
+		return err(this.error);
+	}
+	catchTags(handlers) {
+		const error = this.error;
+		const handled = callTaggedHandler(error, handlers);
+		if (handled.matched) return handled.value;
+		return err(error);
+	}
+	asyncAndThen(_f) {
+		return createResultAsync(Promise.resolve(err(this.error)));
+	}
+	asyncMap(_f) {
+		return createResultAsync(Promise.resolve(err(this.error)));
+	}
+	unwrapOr(defaultValue) {
+		return defaultValue;
+	}
+	match(input, fnErr) {
+		return getMatchErrorHandler(input, fnErr)(this.error);
+	}
+	matchTags(_fnOk, handlers) {
+		return matchTaggedOr(this.error, handlers, (error) => {
+			throw error;
+		});
+	}
+	matchTagsPartial(_fnOk, handlers, fallback) {
+		return matchTaggedOr(this.error, handlers, fallback);
+	}
+	log(fn) {
+		callSyncSideEffect(() => {
+			fn(void 0, this.error);
+		});
+		return this;
+	}
+	tap(_fn) {
+		return this;
+	}
+	tapError(fn) {
+		callSyncSideEffect(() => {
+			fn(this.error);
+		});
+		return this;
+	}
+	toDisposable(f) {
+		return new DisposableResult(this, f);
+	}
+	unwrapOrThrow() {
+		throw this.error;
+	}
+	_unsafeUnwrap(config) {
+		throw createResultarError("Called `_unsafeUnwrap` on an Err", this, config);
+	}
+	_unsafeUnwrapErr(_config) {
+		return this.error;
+	}
+	*[Symbol.iterator]() {
+		yield this;
+		return this;
+	}
+	safeUnwrap() {
+		const { error } = this;
+		return (function* () {
+			yield err(error);
+			throw new Error("Do not use this generator out of `safeTry`");
+		})();
+	}
+};
+/**
+* A `Disposable` is an object that has a `dispose` method that can be used to
+* clean up resources.
+*/
+var DisposableResult = class {
+	disposed = false;
+	finalizer;
+	result;
+	constructor(result, finalizer) {
+		this.result = result;
+		this.finalizer = finalizer;
+	}
+	get value() {
+		return this.result.isOk() ? this.result.value : void 0;
+	}
+	get error() {
+		return this.result.isErr() ? this.result.error : void 0;
+	}
+	_unsafeUnwrap(config) {
+		return this.result._unsafeUnwrap(config);
+	}
+	_unsafeUnwrapErr(config) {
+		return this.result._unsafeUnwrapErr(config);
+	}
+	isOk() {
+		return this.result.isOk();
+	}
+	isErr() {
+		return this.result.isErr();
+	}
+	unwrapOr(defaultValue) {
+		return this.result.unwrapOr(defaultValue);
+	}
+	[Symbol.dispose]() {
+		if (this.disposed) return;
+		this.disposed = true;
+		try {
+			this.finalizer(this.result.isOk() ? this.result.value : void 0, this.result.isErr() ? this.result.error : void 0);
+		} catch {}
+	}
+};
+function safeTry(input) {
+	const body = typeof input === "function" ? input : input.try;
+	const catchFn = typeof input === "function" ? void 0 : input.catch;
+	let n = void 0;
+	try {
+		n = body().next();
+	} catch (error) {
+		if (catchFn) return err(catchFn(error));
+		throw error;
+	}
+	if (n instanceof Promise) return createResultAsync(n.then((r) => r.value).catch((error) => {
+		if (catchFn) return err(catchFn(error));
+		throw error;
+	}));
+	return n.value;
+}
+function ok(value) {
+	return new Ok(value);
+}
+function err(error) {
+	return new Err(error);
+}
+const fromThrowable = Result.fromThrowable;
+function tryResult(input, errorFn) {
+	const fn = typeof input === "function" ? input : input.try;
+	const catchFn = typeof input === "function" ? errorFn : input.catch;
+	try {
+		return ok(fn());
+	} catch (error) {
+		if (catchFn) return err(catchFn(error));
+		return err(error);
+	}
+}
+function unit() {
+	return ok(void 0);
+}
+/** Compatibility alias. Prefer `tryResult` in new code. */
+const tryCatch = tryResult;
+//#endregion
+//#region src/result-async.ts
+function isTryResultAsyncOptions(input) {
+	return typeof input === "object" && input !== null && "try" in input;
+}
+const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen((resultList) => Result.combine(resultList));
+const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen((resultList) => Result.combineWithAllErrors(resultList));
+const validateAllResultAsyncItems = (items, f) => {
+	return combineResultAsyncListWithAllErrors(Array.from(items, f));
+};
+const firstSuccessOfAsyncCandidates = (candidates) => {
+	return new ResultAsync(Promise.try(async () => {
+		let latestError = void 0;
+		let hasCandidates = false;
+		for (const candidate of candidates) {
+			hasCandidates = true;
+			const result = await candidate();
+			if (result.isOk()) return result;
+			latestError = result;
+		}
+		if (!hasCandidates || latestError === void 0) throw createEmptyResultsCollectionError();
+		return latestError;
+	}));
+};
+const loopResultAsync = (initial, options) => {
+	return new ResultAsync(Promise.try(async () => {
+		let state = initial;
+		const values = [];
+		while (options.while(state)) {
+			const result = await options.body(state);
+			if (result.isErr()) return Result.err(result.error);
+			if (options.discard !== true) values.push(result.value);
+			state = options.step(state);
+		}
+		if (options.discard === true) return Result.ok(void 0);
+		return Result.ok(values);
+	}));
+};
+const iterateResultAsync = (initial, options) => {
+	return new ResultAsync(Promise.try(async () => {
+		let state = initial;
+		while (options.while(state)) {
+			const result = await options.body(state);
+			if (result.isErr()) return Result.err(result.error);
+			state = result.value;
+		}
+		return Result.ok(state);
+	}));
+};
+const forEachResultAsync = (items, f, options) => {
+	return new ResultAsync(Promise.try(async () => {
+		const values = [];
+		let index = 0;
+		for (const item of items) {
+			const result = await f(item, index);
+			if (result.isErr()) return Result.err(result.error);
+			if (options?.discard !== true) values.push(result.value);
+			index += 1;
+		}
+		if (options?.discard === true) return Result.ok(void 0);
+		return Result.ok(values);
+	}));
+};
+const resolveResultAsyncBooleanCondition = (condition) => typeof condition === "function" ? condition() : condition;
+const toResultAsync = (result) => {
+	if (result instanceof ResultAsync) return result;
+	return new ResultAsync(Promise.resolve(result));
+};
+const ifResultAsync = (condition, options) => {
+	return new ResultAsync(Promise.try(async () => {
+		return await toResultAsync(resolveResultAsyncBooleanCondition(condition) ? options.onTrue() : options.onFalse());
+	}));
+};
+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 whenResultAsync = (condition, body) => {
+	return new ResultAsync(Promise.try(async () => {
+		if (!resolveResultAsyncBooleanCondition(condition)) return Result.ok(void 0);
+		return await toResultAsync(body());
+	}));
+};
+const whenResultAsyncWithConditionByPredicate = (condition, body, predicate) => {
+	return new ResultAsync(Promise.try(async () => {
+		const conditionResult = await toResultAsync(condition);
+		if (conditionResult.isErr()) return Result.err(conditionResult.error);
+		if (!predicate(conditionResult.value)) return Result.ok(void 0);
+		return await toResultAsync(body());
+	}));
+};
+const whenResultAsyncWithCondition = (condition, body) => whenResultAsyncWithConditionByPredicate(condition, body, (value) => value);
+const unlessResultAsync = (condition, body) => whenResultAsync(() => !resolveResultAsyncBooleanCondition(condition), body);
+const unlessResultAsyncWithCondition = (condition, body) => whenResultAsyncWithConditionByPredicate(condition, body, (value) => !value);
+const matchResolvedResultTags = ({ fallback, handlers, ok, result }) => {
+	if (result.isOk()) return ok(result.value);
+	return matchTaggedOr(result.error, handlers, fallback);
+};
+const callAsyncSideEffect = async (effect) => {
+	try {
+		await effect();
+	} catch {}
+};
+var DisposableResultAsync = class {
+	innerPromise;
+	finalizer;
+	disposed = false;
+	constructor(res, finalizer) {
+		this.innerPromise = res;
+		this.finalizer = finalizer;
+	}
+	then(successCallback, failureCallback) {
+		return this.innerPromise.then(successCallback, failureCallback);
+	}
+	async [Symbol.asyncDispose]() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const result = await this.innerPromise;
+		try {
+			await this.finalizer(result.isOk() ? result.value : void 0, result.isErr() ? result.error : void 0);
+		} catch {}
+	}
+};
+/**
+* Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.
+* This class provides a way to handle asynchronous operations that may succeed with a value of type T
+* or fail with an error of type E.
+*
+* @template T - The type of the success value
+* @template E - The type of the error value
+*
+* @implements {PromiseLike<Result<T, E>>}
+*
+* @example
+* ```typescript
+* // Create a successful async result
+* const okAsync = ResultAsync.okAsync(42);
+*
+* // Create a failed async result
+* const errAsync = ResultAsync.errAsync(new Error("Something went wrong"));
+*
+* // Transform a Promise into a ResultAsync
+* const resultFromPromise = ResultAsync.fromPromise(
+*   fetch("https://api.example.com/data"),
+*   (error) => new Error(`API call failed: ${error}`)
+* );
+* ```
+*
+* @remarks
+* ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.
+* It provides various utility methods for transforming and combining results, similar to the Result type,
+* but operating in an asynchronous context.
+*
+* The class includes methods for:
+* - Creating ResultAsync instances (okAsync, errAsync, fromPromise)
+* - Transforming values (map, mapErr)
+* - Chaining operations (andThen, orElse)
+* - Error handling (tapError)
+* - Conditional branching (if)
+* - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
+*/
+var ResultAsync = class ResultAsync extends Pipeable {
+	static okAsync(value) {
+		return new ResultAsync(Promise.resolve(Result.ok(value)));
+	}
+	/**
+	* Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
+	*
+	* @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
+	*/
+	static unitAsync() {
+		return new ResultAsync(Promise.resolve(Result.unit()));
+	}
+	static errAsync(error) {
+		return new ResultAsync(Promise.resolve(Result.err(error)));
+	}
+	static tryCatch(fn, errorFn) {
+		return new ResultAsync((typeof fn === "function" ? Promise.try(fn) : fn).then((value) => Result.ok(value)).catch((error) => {
+			if (errorFn) return Result.err(errorFn(error));
+			return Result.err(error);
+		}));
+	}
+	static fromSafePromise(promise) {
+		return new ResultAsync(promise.then((value) => Result.ok(value)));
+	}
+	static fromPromise(promise, errorFn) {
+		return new ResultAsync(promise.then((value) => Result.ok(value)).catch((error) => Result.err(errorFn(error))));
+	}
+	static combine(asyncResultList) {
+		return combineResultAsyncList(asyncResultList);
+	}
+	static combineWithAllErrors(asyncResultList) {
+		return combineResultAsyncListWithAllErrors(asyncResultList);
+	}
+	static validateAll(asyncResultListOrItems, f) {
+		if (f === void 0) return combineResultAsyncListWithAllErrors(asyncResultListOrItems);
+		return validateAllResultAsyncItems(asyncResultListOrItems, f);
+	}
+	static zip(left, right) {
+		return combineResultAsyncList([left, right]);
+	}
+	static firstSuccessOf(candidates) {
+		return firstSuccessOfAsyncCandidates(candidates);
+	}
+	static if(condition, options) {
+		if (typeof condition === "boolean" || typeof condition === "function") return ifResultAsync(condition, options);
+		return ifResultAsyncWithCondition(condition, options);
+	}
+	static when(condition, body) {
+		return whenResultAsync(condition, body);
+	}
+	static whenResult(condition, body) {
+		return whenResultAsyncWithCondition(condition, body);
+	}
+	static unless(condition, body) {
+		return unlessResultAsync(condition, body);
+	}
+	static unlessResult(condition, body) {
+		return unlessResultAsyncWithCondition(condition, body);
+	}
+	static loop(initial, options) {
+		return loopResultAsync(initial, options);
+	}
+	static iterate(initial, options) {
+		return iterateResultAsync(initial, options);
+	}
+	static forEach(items, f, options) {
+		return forEachResultAsync(items, f, options);
+	}
+	/**
+	* Wraps a async function with a try catch, creating a new function with the same
+	* arguments but returning `Ok` if successful, `Err` if the function throws
+	*
+	* @param fn function to wrap with ok on success or err on failure
+	* @param errorFn when an error is thrown, this will wrap the error result if provided
+	* @returns a new function that returns a `ResultAsync`
+	*/
+	static fromThrowable(fn, errorFn) {
+		return (...args) => new ResultAsync((async () => {
+			try {
+				const v = await fn(...args);
+				return Result.ok(v);
+			} catch (error) {
+				const e = errorFn ? errorFn(error) : error;
+				return Result.err(e);
+			}
+		})());
+	}
+	innerPromise;
+	constructor(res) {
+		super();
+		this.innerPromise = res;
+	}
+	then(successCallback, failureCallback) {
+		return this.innerPromise.then(successCallback, failureCallback);
+	}
+	mapErr(f) {
+		return new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isOk()) return Result.ok(res.value);
+			return Result.err(await f(res.error));
+		}));
+	}
+	map(f) {
+		return new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isErr()) return Result.err(res.error);
+			return Result.ok(await f(res.value));
+		}));
+	}
+	as(value) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isErr()) return Result.err(res.error);
+			return Result.ok(value);
+		}));
+	}
+	filterOrElse(predicate, onFalse) {
+		return new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isErr()) return Result.err(res.error);
+			if (await predicate(res.value)) return Result.ok(res.value);
+			return Result.err(await onFalse(res.value));
+		}));
+	}
+	andThen(f) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isErr()) return Result.err(res.error);
+			const next = f(res.value);
+			return next instanceof ResultAsync ? next.innerPromise : next;
+		}));
+	}
+	if(fCondition) {
+		return { true: (fTrue) => ({ false: (fFalse) => new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isOk()) return fCondition(res.value) ? fTrue(res.value) : fFalse(res.value);
+			return errAsync(res.error);
+		})) }) };
+	}
+	orElse(f) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isErr()) {
+				const next = f(res.error);
+				return next instanceof ResultAsync ? next.innerPromise : next;
+			}
+			return Result.ok(res.value);
+		}));
+	}
+	catchTag(tag, f) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isOk()) return Result.ok(res.value);
+			if (hasTag(res.error, tag)) {
+				const next = f(res.error);
+				return next instanceof ResultAsync ? next.innerPromise : next;
+			}
+			return Result.err(res.error);
+		}));
+	}
+	catchTags(handlers) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isOk()) return Result.ok(res.value);
+			const error = res.error;
+			const handled = callTaggedHandler(error, handlers);
+			if (handled.matched) {
+				const next = handled.value;
+				return next instanceof ResultAsync ? next.innerPromise : next;
+			}
+			return Result.err(error);
+		}));
+	}
+	async match(input, fnErr) {
+		return this.innerPromise.then((res) => typeof input === "function" ? res.match(input, getMatchErrorHandler(input, fnErr)) : res.match(input));
+	}
+	async matchTags(ok, handlers) {
+		return this.innerPromise.then((res) => matchResolvedResultTags({
+			result: res,
+			ok,
+			handlers,
+			fallback: (error) => {
+				throw error;
+			}
+		}));
+	}
+	async matchTagsPartial(ok, handlers, fallback) {
+		return this.innerPromise.then((res) => matchResolvedResultTags({
+			result: res,
+			ok,
+			handlers,
+			fallback
+		}));
+	}
+	async unwrapOr(t) {
+		return this.innerPromise.then((res) => res.unwrapOr(t));
+	}
+	async unwrapOrThrow() {
+		return this.innerPromise.then((res) => res.unwrapOrThrow());
+	}
+	/**
+	* Runs a side effect for either variant and preserves the original async result.
+	*
+	* For `Ok`, the callback receives `(value, undefined)`.
+	* For `Err`, the callback receives `(undefined, error)`.
+	* Callback errors and rejected callback promises are intentionally ignored.
+	*
+	* Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should
+	* transform the result.
+	*/
+	log(f) {
+		return new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isOk()) {
+				await callAsyncSideEffect(() => f(res.value));
+				return okAsync(res.value);
+			}
+			await callAsyncSideEffect(() => f(void 0, res.error));
+			return errAsync(res.error);
+		}));
+	}
+	/**
+	* Runs a side effect only for the `Ok` variant and preserves the original async result.
+	*
+	* Callback errors and rejected callback promises are intentionally ignored.
+	* Use `map` or `andThen` when the callback should transform the value.
+	*/
+	tap(f) {
+		return new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isErr()) return errAsync(res.error);
+			await callAsyncSideEffect(() => f(res.value));
+			return okAsync(res.value);
+		}));
+	}
+	/**
+	* Runs a side effect only for the `Err` variant and preserves the original async result.
+	*
+	* Callback errors and rejected callback promises are intentionally ignored.
+	* Use `mapErr` or `orElse` when the callback should transform the error.
+	*/
+	tapError(f) {
+		return new ResultAsync(this.innerPromise.then(async (res) => {
+			if (res.isErr()) {
+				await callAsyncSideEffect(() => f(res.error));
+				return errAsync(res.error);
+			}
+			return okAsync(res.value);
+		}));
+	}
+	toAsyncDisposable(f) {
+		return new DisposableResultAsync(this.innerPromise, f);
+	}
+	async *[Symbol.asyncIterator]() {
+		const result = await this.innerPromise;
+		if (result.isOk()) return result.value;
+		yield err(result.error);
+		return void 0;
+	}
+};
+registerResultAsyncFactory((promise) => new ResultAsync(promise));
+const okAsync = ResultAsync.okAsync;
+const errAsync = ResultAsync.errAsync;
+const fromPromise = ResultAsync.fromPromise;
+const fromSafePromise = ResultAsync.fromSafePromise;
+const unitAsync = ResultAsync.unitAsync;
+const fromThrowableAsync = ResultAsync.fromThrowable;
+function tryResultAsync(input, errorFn) {
+	const promiseOrFn = isTryResultAsyncOptions(input) ? input.try : input;
+	const catchFn = isTryResultAsyncOptions(input) ? input.catch : errorFn;
+	return new ResultAsync((typeof promiseOrFn === "function" ? Promise.try(promiseOrFn) : promiseOrFn).then((value) => Result.ok(value)).catch((error) => {
+		if (catchFn) return Result.err(catchFn(error));
+		return Result.err(error);
+	}));
+}
+/** Compatibility alias. Prefer `tryResultAsync` in new code. */
+const tryCatchAsync = tryResultAsync;
+//#endregion
 //#region src/tagged-error.ts
 const defaultBaseError = Error;
 const defaultMessageTemplate = "$message";
 const nativeError = Error;
-const templateVariableMatcher = /\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+const templateVariableMatcher = /\$([a-zA-Z_][a-zA-Z0-9_]*)/gu;
 const reservedTemplateVariables = new Set([
 	"_tag",
 	"cause",
@@ -16,14 +1001,26 @@ const reservedTemplateVariables = new Set([
 function isError(value) {
 	return nativeError.isError?.(value) ?? value instanceof Error;
 }
-const stringifyTemplateValue = (value) => {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return value.toString();
-	if (typeof value === "symbol") return value.description ?? value.toString();
-	if (typeof value === "function") return value.name;
-	if (typeof value === "object") return value === null ? "null" : JSON.stringify(value) ?? Object.prototype.toString.call(value);
-	return "";
+const stringifyDirectTemplateValue = String;
+const stringifySymbolTemplateValue = (value) => {
+	const symbol = value;
+	return symbol.description ?? symbol.toString();
+};
+const stringifyFunctionTemplateValue = (value) => value.name;
+const stringifyObjectTemplateValue = (value) => {
+	if (value === null) return "null";
+	return 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) => templateValueStringifiers[typeof value]?.(value) ?? "";
 const compileMessageInterpolator = (template) => (values) => template.replaceAll(templateVariableMatcher, (variable, key) => {
 	const value = values?.[key];
 	return value === void 0 ? variable : stringifyTemplateValue(value);
@@ -123,6 +1120,6 @@ const matchErrorPartial = (error, handlers, fallback) => {
 	return fallback(error);
 };
 //#endregion
-export { DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryCatch, tryCatchAsync, unit, unitAsync };
+export { DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
 
 //# sourceMappingURL=index.js.map