@shirudo/result 0.0.6 → 1.0.0

package/dist/result-CY-KIivk.cjs

@@ -0,0 +1,1100 @@
+const require_errors = require('./errors-D2EMzJQl.cjs');
+
+//#region src/core/pipeable.ts
+var Pipeable = class {
+	pipe(...ops) {
+		let ret = this;
+		for (const op of ops) ret = op(ret);
+		return ret;
+	}
+	async pipeAsync(...ops) {
+		let ret = this;
+		for (const op of ops) ret = await op(ret);
+		return ret;
+	}
+};
+
+//#endregion
+//#region src/core/brand.ts
+const RESULT_BRAND = Symbol.for("@shirudo/result.brand");
+
+//#endregion
+//#region src/core/isResult.ts
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const hasResultMethods = (value) => {
+	return typeof value.isOk === "function" && typeof value.isErr === "function";
+};
+const hasValidPayload = (value) => {
+	if (value._tag === "Ok") return hasOwn(value, "value") && !hasOwn(value, "error");
+	if (value._tag === "Err") return hasOwn(value, "error") && !hasOwn(value, "value");
+	return false;
+};
+/**
+* Checks whether a value is a Result.
+* Pure function alternative for runtime checks.
+*/
+function isResult(value) {
+	if (value === null || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate[RESULT_BRAND] === true && hasResultMethods(candidate) && hasValidPayload(candidate);
+}
+
+//#endregion
+//#region src/core/matcher.ts
+const matchesTag = (value, key, tag) => {
+	return value !== null && typeof value === "object" && value[key] === tag;
+};
+function matchTag(result, key, handlers) {
+	if (result.isOk()) throw new require_errors.MatchOnOkError("matchTag");
+	if (result.isErr()) {
+		const error = result.error;
+		const handler = handlers[error[key]];
+		if (typeof handler !== "function") throw new require_errors.InvalidResultStateError("matchTag");
+		return handler(error);
+	}
+	throw new require_errors.InvalidResultStateError("matchTag");
+}
+/**
+* Matcher for Err values (returns an arbitrary return type, e.g. string messages).
+*
+* - `.when(Ctor, handler)` matches via `instanceof`
+* - `.whenGuard(guard, handler)` matches via Type-Guard
+* - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`)
+*/
+var ErrorMatchBuilder = class ErrorMatchBuilder {
+	#error;
+	#matched;
+	#value;
+	constructor(error, matched = false, value) {
+		this.#error = error;
+		this.#matched = matched;
+		this.#value = value;
+		Object.freeze(this);
+	}
+	when(ctor, handler) {
+		if (this.#matched) return this;
+		if (this.#error instanceof ctor) return new ErrorMatchBuilder(this.#error, true, handler(this.#error));
+		return this;
+	}
+	whenGuard(guard, handler) {
+		if (this.#matched) return this;
+		const error = this.#error;
+		if (guard(error)) return new ErrorMatchBuilder(this.#error, true, handler(error));
+		return this;
+	}
+	whenTag(key, tag, handler) {
+		if (this.#matched) return this;
+		if (matchesTag(this.#error, key, tag)) return new ErrorMatchBuilder(this.#error, true, handler(this.#error));
+		return this;
+	}
+	otherwise(handler) {
+		if (this.#matched) return this.#value;
+		return handler(this.#error);
+	}
+	run() {
+		if (this.#matched) return this.#value;
+		throw this.#error;
+	}
+};
+var AsyncErrorMatchBuilder = class AsyncErrorMatchBuilder {
+	#error;
+	#matched;
+	#value;
+	constructor(error, matched = false, value) {
+		this.#error = error;
+		this.#matched = matched;
+		this.#value = value;
+		Object.freeze(this);
+	}
+	when(ctor, handler) {
+		if (this.#matched) return this;
+		if (this.#error instanceof ctor) {
+			const value = Promise.resolve().then(() => handler(this.#error));
+			return new AsyncErrorMatchBuilder(this.#error, true, value);
+		}
+		return this;
+	}
+	whenGuard(guard, handler) {
+		if (this.#matched) return this;
+		const error = this.#error;
+		if (guard(error)) {
+			const value = Promise.resolve().then(() => handler(error));
+			return new AsyncErrorMatchBuilder(this.#error, true, value);
+		}
+		return this;
+	}
+	whenTag(key, tag, handler) {
+		if (this.#matched) return this;
+		if (matchesTag(this.#error, key, tag)) {
+			const value = Promise.resolve().then(() => handler(this.#error));
+			return new AsyncErrorMatchBuilder(this.#error, true, value);
+		}
+		return this;
+	}
+	async otherwise(handler) {
+		if (this.#matched) return await this.#value;
+		return await handler(this.#error);
+	}
+	async run() {
+		if (this.#matched) return await this.#value;
+		throw this.#error;
+	}
+};
+const expectResultReturn = (value, handlerName) => {
+	if (isResult(value)) return value;
+	throw new require_errors.MatchErrHandlerNotResultError(handlerName, value);
+};
+/**
+* Matcher for `Result` Errors, which returns a `Result` again.
+*
+* Handlers must return a `Result`.
+* Wrap recovered values with `ok(...)` and mapped errors with `err(...)`.
+*/
+var ErrMatchBuilder = class ErrMatchBuilder {
+	#error;
+	#resolved;
+	constructor(error, resolved) {
+		this.#error = error;
+		this.#resolved = resolved;
+		Object.freeze(this);
+	}
+	static fromResult(result) {
+		if (result.isOk()) return new ErrMatchBuilder(void 0, result);
+		if (result.isErr()) return new ErrMatchBuilder(result.error);
+		throw new require_errors.InvalidResultStateError("ErrMatchBuilder.fromResult");
+	}
+	when(ctor, handler) {
+		if (this.#resolved) return this;
+		if (this.#error instanceof ctor) {
+			const resolved = expectResultReturn(handler(this.#error), "when");
+			return new ErrMatchBuilder(this.#error, resolved);
+		}
+		return this;
+	}
+	whenGuard(guard, handler) {
+		if (this.#resolved) return this;
+		const error = this.#error;
+		if (guard(error)) {
+			const resolved = expectResultReturn(handler(error), "whenGuard");
+			return new ErrMatchBuilder(this.#error, resolved);
+		}
+		return this;
+	}
+	whenTag(key, tag, handler) {
+		if (this.#resolved) return this;
+		if (matchesTag(this.#error, key, tag)) {
+			const resolved = expectResultReturn(handler(this.#error), "whenTag");
+			return new ErrMatchBuilder(this.#error, resolved);
+		}
+		return this;
+	}
+	otherwise(handler) {
+		if (this.#resolved) return this.#resolved;
+		return expectResultReturn(handler(this.#error), "otherwise");
+	}
+	run() {
+		if (this.#resolved) return this.#resolved;
+		throw this.#error;
+	}
+};
+var AsyncErrMatchBuilder = class AsyncErrMatchBuilder {
+	#error;
+	#resolved;
+	constructor(error, resolved) {
+		this.#error = error;
+		this.#resolved = resolved;
+		Object.freeze(this);
+	}
+	static fromResult(result) {
+		if (result.isOk()) return new AsyncErrMatchBuilder(void 0, Promise.resolve(result));
+		if (result.isErr()) return new AsyncErrMatchBuilder(result.error);
+		throw new require_errors.InvalidResultStateError("AsyncErrMatchBuilder.fromResult");
+	}
+	when(ctor, handler) {
+		if (this.#resolved) return this;
+		if (this.#error instanceof ctor) {
+			const resolved = Promise.resolve().then(() => handler(this.#error)).then((out) => expectResultReturn(out, "when"));
+			return new AsyncErrMatchBuilder(this.#error, resolved);
+		}
+		return this;
+	}
+	whenGuard(guard, handler) {
+		if (this.#resolved) return this;
+		const error = this.#error;
+		if (guard(error)) {
+			const resolved = Promise.resolve().then(() => handler(error)).then((out) => expectResultReturn(out, "whenGuard"));
+			return new AsyncErrMatchBuilder(this.#error, resolved);
+		}
+		return this;
+	}
+	whenTag(key, tag, handler) {
+		if (this.#resolved) return this;
+		if (matchesTag(this.#error, key, tag)) {
+			const resolved = Promise.resolve().then(() => handler(this.#error)).then((out) => expectResultReturn(out, "whenTag"));
+			return new AsyncErrMatchBuilder(this.#error, resolved);
+		}
+		return this;
+	}
+	async otherwise(handler) {
+		if (this.#resolved) return await this.#resolved;
+		return expectResultReturn(await handler(this.#error), "otherwise");
+	}
+	async run() {
+		if (this.#resolved) return await this.#resolved;
+		throw this.#error;
+	}
+};
+
+//#endregion
+//#region src/core/sequence.ts
+/**
+* Combines a list of Results into a single Result of a list.
+* Short-circuits on the first Err.
+* Analogous to Rust `collect::<Result<Vec<_>, _>>()`.
+*/
+function sequence(results) {
+	const values = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			values.push(result.value);
+			continue;
+		}
+		if (result.isErr()) return result;
+		throw new require_errors.InvalidResultStateError("sequence");
+	}
+	return ok(values);
+}
+/**
+* Alias for `sequence`.
+*/
+function all(results) {
+	return sequence(results);
+}
+
+//#endregion
+//#region src/core/zip.ts
+function zipImpl(left, right) {
+	if (left.isErr()) return left;
+	if (right.isErr()) return right;
+	if (left.isOk() && right.isOk()) return ok([left.value, right.value]);
+	throw new require_errors.InvalidResultStateError("zip");
+}
+function zip(...args) {
+	if (args.length === 1) {
+		const right$1 = args[0];
+		return (left$1) => zipImpl(left$1, right$1);
+	}
+	const [left, right] = args;
+	return zipImpl(left, right);
+}
+function combineImpl(left, right) {
+	if (left.isOk() && right.isOk()) return ok([left.value, right.value]);
+	const errors = [];
+	if (left.isErr()) errors.push(left.error);
+	if (right.isErr()) errors.push(right.error);
+	if (!left.isOk() && !left.isErr()) throw new require_errors.InvalidResultStateError("combine");
+	if (!right.isOk() && !right.isErr()) throw new require_errors.InvalidResultStateError("combine");
+	return err(errors);
+}
+function combine(...args) {
+	if (args.length === 1) {
+		const right$1 = args[0];
+		return (left$1) => combineImpl(left$1, right$1);
+	}
+	const [left, right] = args;
+	return combineImpl(left, right);
+}
+
+//#endregion
+//#region src/core/map.ts
+/**
+* Transforms the value (Ok case).
+* Corresponds to Rust `map`.
+*/
+function map(project) {
+	return (source) => {
+		if (source.isOk()) return ok(project(source.value));
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("map");
+	};
+}
+
+//#endregion
+//#region src/core/mapErr.ts
+/**
+* Transforms the error (Err case).
+* Corresponds to Rust `map_err`.
+*/
+function mapErr(project) {
+	return (source) => {
+		if (source.isErr()) return err(project(source.error));
+		if (source.isOk()) return source;
+		throw new require_errors.InvalidResultStateError("mapErr");
+	};
+}
+
+//#endregion
+//#region src/core/mapBoth.ts
+/**
+* Transforms both the Ok value and the Err error.
+* Corresponds to FP `bimap` / `mapBoth`.
+*/
+function mapBoth(mapOk, mapErr$1) {
+	return (source) => {
+		if (source.isOk()) return ok(mapOk(source.value));
+		if (source.isErr()) return err(mapErr$1(source.error));
+		throw new require_errors.InvalidResultStateError("mapBoth");
+	};
+}
+/**
+* Alias for `mapBoth`.
+*/
+const bimap = mapBoth;
+
+//#endregion
+//#region src/core/flatMap.ts
+/**
+* Chains another operation that returns a Result.
+* Corresponds to Rust `and_then` or JS `flatMap`.
+*/
+function flatMap(project) {
+	return (source) => {
+		if (source.isOk()) return project(source.value);
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("flatMap");
+	};
+}
+
+//#endregion
+//#region src/core/tap.ts
+/**
+* Executes a side effect (logging, debugging) without changing the Result.
+* Corresponds to Rust `inspect` / `inspect_err`.
+*/
+function tap(observer) {
+	return (source) => {
+		if (source.isOk()) {
+			if (observer.ok) observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) observer.err(source.error);
+			return source;
+		}
+		throw new require_errors.InvalidResultStateError("tap");
+	};
+}
+
+//#endregion
+//#region src/core/filter.ts
+/**
+* Checks a condition. If false, the Result becomes Err.
+* Corresponds to Rust `filter` (partially).
+*/
+function filter(predicate, errorFn) {
+	return (source) => {
+		if (source.isOk()) {
+			if (predicate(source.value)) return source;
+			return err(errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("filter");
+	};
+}
+
+//#endregion
+//#region src/core/match.ts
+/**
+* Resolves the Result. The end of the pipe.
+* Corresponds to Rust `match`.
+*/
+function match(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("match");
+	};
+}
+
+//#endregion
+//#region src/core/recover.ts
+/**
+* Recover: converts Err to Ok(defaultValue).
+* Result is guaranteed to be Ok → Error type becomes `never`.
+*/
+function recover(defaultValue) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return ok(defaultValue);
+		throw new require_errors.InvalidResultStateError("recover");
+	};
+}
+/**
+* Like `recover`, but calculates the default value based on the error.
+*/
+function recoverWith(fn) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return ok(fn(source.error));
+		throw new require_errors.InvalidResultStateError("recoverWith");
+	};
+}
+
+//#endregion
+//#region src/core/swap.ts
+/**
+* Swaps Ok and Err.
+* Result<T, E> → Result<E, T>
+*/
+function swap(result) {
+	if (result.isOk()) return err(result.value);
+	if (result.isErr()) return ok(result.error);
+	throw new require_errors.InvalidResultStateError("swap");
+}
+
+//#endregion
+//#region src/core/tryCatch.ts
+/**
+* Executes a function and catches exceptions.
+* Converts exceptions into Result<E>.
+* Corresponds to Rust `Result::from` for fallible operations.
+*/
+function tryCatch(fn, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		try {
+			return ok(fn());
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMap.ts
+/**
+* Like `map`, but catches exceptions and converts them to Err.
+*/
+function tryMap(project, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new require_errors.InvalidResultStateError("tryMap");
+		try {
+			return ok(project(source.value));
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/collectFirstOk.ts
+/**
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
+*/
+function collectFirstOk(results) {
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) return ok(result.value);
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new require_errors.InvalidResultStateError("collectFirstOk");
+	}
+	return err(errors);
+}
+
+//#endregion
+//#region src/core/mapAsync.ts
+/**
+* Async version of map.
+*/
+function mapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return ok(await project(source.value));
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("mapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/mapErrAsync.ts
+/**
+* Async version of mapErr.
+*/
+function mapErrAsync(project) {
+	return async (source) => {
+		if (source.isErr()) return err(await project(source.error));
+		if (source.isOk()) return source;
+		throw new require_errors.InvalidResultStateError("mapErrAsync");
+	};
+}
+
+//#endregion
+//#region src/core/flatMapAsync.ts
+/**
+* Async version of flatMap.
+*/
+function flatMapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return await project(source.value);
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("flatMapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tapAsync.ts
+/**
+* Async version of tap.
+*/
+function tapAsync(observer) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (observer.ok) await observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) await observer.err(source.error);
+			return source;
+		}
+		throw new require_errors.InvalidResultStateError("tapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/filterAsync.ts
+/**
+* Async version of filter.
+*/
+function filterAsync(predicate, errorFn) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (await predicate(source.value)) return source;
+			return err(await errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("filterAsync");
+	};
+}
+
+//#endregion
+//#region src/core/matchAsync.ts
+/**
+* Async version of match.
+*/
+function matchAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("matchAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatchAsync.ts
+/**
+* Async version of tryCatch.
+*/
+function tryCatchAsync(fn, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		try {
+			return ok(await fn());
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMapAsync.ts
+/**
+* Async version of tryMap.
+*/
+function tryMapAsync(project, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new require_errors.InvalidResultStateError("tryMapAsync");
+		try {
+			return ok(await project(source.value));
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/result.ts
+var ResultBase = class extends Pipeable {
+	constructor() {
+		super();
+		Object.defineProperty(this, RESULT_BRAND, {
+			value: true,
+			enumerable: false,
+			configurable: false,
+			writable: false
+		});
+	}
+	isOk() {
+		if (this._tag === "Ok") return true;
+		if (this._tag === "Err") return false;
+		throw new require_errors.InvalidResultStateError("Result.isOk");
+	}
+	isErr() {
+		if (this._tag === "Err") return true;
+		if (this._tag === "Ok") return false;
+		throw new require_errors.InvalidResultStateError("Result.isErr");
+	}
+	unwrapOr(defaultValue) {
+		if (this._tag === "Ok") return this.value;
+		if (this._tag === "Err") return defaultValue;
+		throw new require_errors.InvalidResultStateError("Result.unwrapOr");
+	}
+	unwrap() {
+		if (this._tag === "Ok") return this.value;
+		if (this._tag === "Err") throw new require_errors.UnwrapOnErrError(this.error);
+		throw new require_errors.InvalidResultStateError("Result.unwrap");
+	}
+	unwrapErr() {
+		if (this._tag === "Err") return this.error;
+		if (this._tag === "Ok") throw new require_errors.UnwrapErrOnOkError(this.value);
+		throw new require_errors.InvalidResultStateError("Result.unwrapErr");
+	}
+	unwrapOrElse(fn) {
+		if (this._tag === "Ok") return this.value;
+		if (this._tag === "Err") return fn(this.error);
+		throw new require_errors.InvalidResultStateError("Result.unwrapOrElse");
+	}
+	unwrapOrThrow() {
+		if (this._tag === "Ok") return this.value;
+		if (this._tag === "Err") throw this.error;
+		throw new require_errors.InvalidResultStateError("Result.unwrapOrThrow");
+	}
+	expect(message) {
+		if (this._tag === "Ok") return this.value;
+		if (this._tag === "Err") throw new require_errors.ExpectOkError(message);
+		throw new require_errors.InvalidResultStateError("Result.expect");
+	}
+	expectErr(message) {
+		if (this._tag === "Err") return this.error;
+		if (this._tag === "Ok") throw new require_errors.ExpectErrError(message);
+		throw new require_errors.InvalidResultStateError("Result.expectErr");
+	}
+	toPromise() {
+		if (this._tag === "Ok") return Promise.resolve(this.value);
+		if (this._tag === "Err") return Promise.reject(this.error);
+		throw new require_errors.InvalidResultStateError("Result.toPromise");
+	}
+	toNullable() {
+		if (this._tag === "Ok") return this.value;
+		if (this._tag === "Err") return null;
+		throw new require_errors.InvalidResultStateError("Result.toNullable");
+	}
+	/**
+	* Folds the Result into a single value by applying one of two functions.
+	*/
+	fold(onOk, onErr) {
+		if (this._tag === "Ok") return onOk(this.value);
+		if (this._tag === "Err") return onErr(this.error);
+		throw new require_errors.InvalidResultStateError("Result.fold");
+	}
+	/**
+	* Enables `yield* result` in generators (Do-notation).
+	*
+	* The iterator yields the `Result` itself; the runner (see `task`) decides:
+	* - Ok  → sends back the Ok value (`next(value)`), `yield*` yields `T`
+	* - Err → aborts and returns the Err Result
+	*/
+	*[Symbol.iterator]() {
+		return yield this;
+	}
+	matchError() {
+		if (this._tag === "Err") return new ErrorMatchBuilder(this.error);
+		if (this._tag === "Ok") throw new require_errors.MatchOnOkError("matchError");
+		throw new require_errors.InvalidResultStateError("Result.matchError");
+	}
+	matchErrorAsync() {
+		if (this._tag === "Err") return new AsyncErrorMatchBuilder(this.error);
+		if (this._tag === "Ok") throw new require_errors.MatchOnOkError("matchErrorAsync");
+		throw new require_errors.InvalidResultStateError("Result.matchErrorAsync");
+	}
+	/**
+	* Matches on the Err value via `.when(...)` chain.
+	*
+	* Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,
+	* e.g. inside `if (result.isErr()) { ... }`.
+	*
+	* @deprecated Use `.matchError()` for clearer Err-only semantics.
+	*/
+	match() {
+		if (this._tag === "Err") return new ErrorMatchBuilder(this.error);
+		if (this._tag === "Ok") throw new require_errors.MatchOnOkError();
+		throw new require_errors.InvalidResultStateError("Result.match");
+	}
+	/**
+	* Matches on the Err value, but normalizes every branch to a `Result`:
+	* - Handlers must return a `Result`
+	* - use `ok(...)` for recovery and `err(...)` for mapped errors
+	*/
+	matchErr() {
+		return ErrMatchBuilder.fromResult(this);
+	}
+	matchErrAsync() {
+		return AsyncErrMatchBuilder.fromResult(this);
+	}
+	/**
+	* Serializes the Result into a simple object format.
+	* Preserves the original types.
+	*/
+	serialize() {
+		if (this._tag === "Ok") return {
+			isSuccess: true,
+			data: this.value
+		};
+		if (this._tag === "Err") return {
+			isSuccess: false,
+			error: this.error
+		};
+		throw new require_errors.InvalidResultStateError("Result.serialize");
+	}
+	/**
+	* Serializes the Result into a user-friendly format.
+	* Converts Errors to readable strings.
+	*/
+	toUserFriendly() {
+		if (this._tag === "Ok") return {
+			isSuccess: true,
+			data: this.value
+		};
+		if (this._tag !== "Err") throw new require_errors.InvalidResultStateError("Result.toUserFriendly");
+		const error = this.error;
+		return {
+			isSuccess: false,
+			error: error && typeof error === "object" && "message" in error ? String(error.message) : String(error)
+		};
+	}
+};
+var Ok = class extends ResultBase {
+	_tag = "Ok";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+		Object.freeze(this);
+	}
+};
+var Err = class extends ResultBase {
+	_tag = "Err";
+	error;
+	constructor(error) {
+		super();
+		this.error = error;
+		Object.freeze(this);
+	}
+};
+function ok(value) {
+	return new Ok(value);
+}
+function err(error) {
+	return new Err(error);
+}
+function okIf(condition, okValue, errValue) {
+	return condition ? ok(okValue) : err(errValue);
+}
+function okIfLazy(condition, okFn, errFn) {
+	return condition ? ok(okFn()) : err(errFn());
+}
+function fromNullable(value, error) {
+	if (value === null || value === void 0) return err(error);
+	return ok(value);
+}
+async function fromPromise(promise, errorMapper) {
+	try {
+		return ok(await promise);
+	} catch (error) {
+		return err(errorMapper ? errorMapper(error) : error);
+	}
+}
+function tryFn(fn) {
+	try {
+		return ok(fn());
+	} catch (error) {
+		return err(error);
+	}
+}
+function fromThrowable(fn, errorMapper) {
+	return (...args) => {
+		try {
+			return ok(fn(...args));
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+async function tryAsync(fn, errorMapper) {
+	try {
+		return ok(await fn());
+	} catch (error) {
+		return err(errorMapper ? errorMapper(error) : error);
+	}
+}
+const Result = {
+	ok,
+	err,
+	is: isResult,
+	fromNullable,
+	fromPromise,
+	fromThrowable,
+	try: tryFn,
+	tryAsync,
+	sequence,
+	all,
+	combine
+};
+
+//#endregion
+Object.defineProperty(exports, 'Err', {
+  enumerable: true,
+  get: function () {
+    return Err;
+  }
+});
+Object.defineProperty(exports, 'Ok', {
+  enumerable: true,
+  get: function () {
+    return Ok;
+  }
+});
+Object.defineProperty(exports, 'Result', {
+  enumerable: true,
+  get: function () {
+    return Result;
+  }
+});
+Object.defineProperty(exports, 'all', {
+  enumerable: true,
+  get: function () {
+    return all;
+  }
+});
+Object.defineProperty(exports, 'bimap', {
+  enumerable: true,
+  get: function () {
+    return bimap;
+  }
+});
+Object.defineProperty(exports, 'collectFirstOk', {
+  enumerable: true,
+  get: function () {
+    return collectFirstOk;
+  }
+});
+Object.defineProperty(exports, 'combine', {
+  enumerable: true,
+  get: function () {
+    return combine;
+  }
+});
+Object.defineProperty(exports, 'err', {
+  enumerable: true,
+  get: function () {
+    return err;
+  }
+});
+Object.defineProperty(exports, 'filter', {
+  enumerable: true,
+  get: function () {
+    return filter;
+  }
+});
+Object.defineProperty(exports, 'filterAsync', {
+  enumerable: true,
+  get: function () {
+    return filterAsync;
+  }
+});
+Object.defineProperty(exports, 'flatMap', {
+  enumerable: true,
+  get: function () {
+    return flatMap;
+  }
+});
+Object.defineProperty(exports, 'flatMapAsync', {
+  enumerable: true,
+  get: function () {
+    return flatMapAsync;
+  }
+});
+Object.defineProperty(exports, 'fromNullable', {
+  enumerable: true,
+  get: function () {
+    return fromNullable;
+  }
+});
+Object.defineProperty(exports, 'fromPromise', {
+  enumerable: true,
+  get: function () {
+    return fromPromise;
+  }
+});
+Object.defineProperty(exports, 'fromThrowable', {
+  enumerable: true,
+  get: function () {
+    return fromThrowable;
+  }
+});
+Object.defineProperty(exports, 'isResult', {
+  enumerable: true,
+  get: function () {
+    return isResult;
+  }
+});
+Object.defineProperty(exports, 'map', {
+  enumerable: true,
+  get: function () {
+    return map;
+  }
+});
+Object.defineProperty(exports, 'mapAsync', {
+  enumerable: true,
+  get: function () {
+    return mapAsync;
+  }
+});
+Object.defineProperty(exports, 'mapBoth', {
+  enumerable: true,
+  get: function () {
+    return mapBoth;
+  }
+});
+Object.defineProperty(exports, 'mapErr', {
+  enumerable: true,
+  get: function () {
+    return mapErr;
+  }
+});
+Object.defineProperty(exports, 'mapErrAsync', {
+  enumerable: true,
+  get: function () {
+    return mapErrAsync;
+  }
+});
+Object.defineProperty(exports, 'match', {
+  enumerable: true,
+  get: function () {
+    return match;
+  }
+});
+Object.defineProperty(exports, 'matchAsync', {
+  enumerable: true,
+  get: function () {
+    return matchAsync;
+  }
+});
+Object.defineProperty(exports, 'matchTag', {
+  enumerable: true,
+  get: function () {
+    return matchTag;
+  }
+});
+Object.defineProperty(exports, 'ok', {
+  enumerable: true,
+  get: function () {
+    return ok;
+  }
+});
+Object.defineProperty(exports, 'okIf', {
+  enumerable: true,
+  get: function () {
+    return okIf;
+  }
+});
+Object.defineProperty(exports, 'okIfLazy', {
+  enumerable: true,
+  get: function () {
+    return okIfLazy;
+  }
+});
+Object.defineProperty(exports, 'recover', {
+  enumerable: true,
+  get: function () {
+    return recover;
+  }
+});
+Object.defineProperty(exports, 'recoverWith', {
+  enumerable: true,
+  get: function () {
+    return recoverWith;
+  }
+});
+Object.defineProperty(exports, 'sequence', {
+  enumerable: true,
+  get: function () {
+    return sequence;
+  }
+});
+Object.defineProperty(exports, 'swap', {
+  enumerable: true,
+  get: function () {
+    return swap;
+  }
+});
+Object.defineProperty(exports, 'tap', {
+  enumerable: true,
+  get: function () {
+    return tap;
+  }
+});
+Object.defineProperty(exports, 'tapAsync', {
+  enumerable: true,
+  get: function () {
+    return tapAsync;
+  }
+});
+Object.defineProperty(exports, 'tryAsync', {
+  enumerable: true,
+  get: function () {
+    return tryAsync;
+  }
+});
+Object.defineProperty(exports, 'tryCatch', {
+  enumerable: true,
+  get: function () {
+    return tryCatch;
+  }
+});
+Object.defineProperty(exports, 'tryCatchAsync', {
+  enumerable: true,
+  get: function () {
+    return tryCatchAsync;
+  }
+});
+Object.defineProperty(exports, 'tryFn', {
+  enumerable: true,
+  get: function () {
+    return tryFn;
+  }
+});
+Object.defineProperty(exports, 'tryMap', {
+  enumerable: true,
+  get: function () {
+    return tryMap;
+  }
+});
+Object.defineProperty(exports, 'tryMapAsync', {
+  enumerable: true,
+  get: function () {
+    return tryMapAsync;
+  }
+});
+Object.defineProperty(exports, 'zip', {
+  enumerable: true,
+  get: function () {
+    return zip;
+  }
+});
+//# sourceMappingURL=result-CY-KIivk.cjs.map