@shirudo/result 0.0.6 → 1.0.1

package/dist/index.mjs

@@ -1,679 +1,8 @@
-//#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/errors.ts
-const ERR_INVALID_STATE = "ERR_INVALID_STATE";
-const ERR_TASK_YIELD_NOT_RESULT = "ERR_TASK_YIELD_NOT_RESULT";
-const ERR_MATCH_ON_OK = "ERR_MATCH_ON_OK";
-const ERR_UNWRAP_ON_ERR = "ERR_UNWRAP_ON_ERR";
-const ERR_UNWRAP_ERR_ON_OK = "ERR_UNWRAP_ERR_ON_OK";
-const ERR_EXPECT_OK = "ERR_EXPECT_OK";
-const ERR_EXPECT_ERR = "ERR_EXPECT_ERR";
-const formatResultErrorMessage = (code, message, context) => {
-	if (context) return `${code}: ${message} (context: ${context})`;
-	return `${code}: ${message}`;
-};
-var ResultError = class extends Error {
-	code;
-	context;
-	constructor(message, code, context) {
-		super(formatResultErrorMessage(code, message, context));
-		this.code = code;
-		this.context = context;
-		this.name = new.target.name;
-		Object.setPrototypeOf(this, new.target.prototype);
-	}
-};
-var ResultTypeError = class extends TypeError {
-	code;
-	context;
-	constructor(message, code, context) {
-		super(formatResultErrorMessage(code, message, context));
-		this.code = code;
-		this.context = context;
-		this.name = new.target.name;
-		Object.setPrototypeOf(this, new.target.prototype);
-	}
-};
-const INVALID_RESULT_STATE_MESSAGE = "Unreachable: Result is neither Ok nor Err";
-var InvalidResultStateError = class extends ResultError {
-	constructor(context) {
-		super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_STATE, context);
-	}
-};
-var TaskYieldNotResultError = class extends ResultTypeError {
-	yieldedValue;
-	constructor(yieldedValue) {
-		super("task() expected yielded values to be Result. Use `yield*` on a Result.", ERR_TASK_YIELD_NOT_RESULT);
-		this.yieldedValue = yieldedValue;
-	}
-};
-var MatchOnOkError = class extends ResultTypeError {
-	constructor() {
-		super("match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.", ERR_MATCH_ON_OK);
-	}
-};
-var UnwrapOnErrError = class extends ResultTypeError {
-	errorValue;
-	constructor(errorValue) {
-		super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);
-		this.errorValue = errorValue;
-	}
-};
-var UnwrapErrOnOkError = class extends ResultTypeError {
-	okValue;
-	constructor(okValue) {
-		super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);
-		this.okValue = okValue;
-	}
-};
-var ExpectOkError = class extends ResultError {
-	expectedMessage;
-	constructor(expectedMessage) {
-		super(expectedMessage, ERR_EXPECT_OK);
-		this.expectedMessage = expectedMessage;
-	}
-};
-var ExpectErrError = class extends ResultError {
-	expectedMessage;
-	constructor(expectedMessage) {
-		super(expectedMessage, ERR_EXPECT_ERR);
-		this.expectedMessage = expectedMessage;
-	}
-};
-
-//#endregion
-//#region src/core/matcher.ts
-/**
-* 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;
-	}
-	otherwise(handler) {
-		if (this.#matched) return this.#value;
-		return handler(this.#error);
-	}
-	run() {
-		if (this.#matched) return this.#value;
-		throw this.#error;
-	}
-};
-function isResult$1(value) {
-	return typeof value === "object" && value !== null && "isOk" in value && typeof value.isOk === "function" && "isErr" in value && typeof value.isErr === "function";
-}
-/**
-* Matcher for `Result` Errors, which returns a `Result` again.
-*
-* Handlers may:
-* - return a `Result` (is returned directly)
-* - return an Error value (is automatically wrapped into `Err(error)`)
-*/
-var ErrMatchBuilder = class ErrMatchBuilder {
-	#makeErr;
-	#error;
-	#resolved;
-	constructor(makeErr, error, resolved) {
-		this.#makeErr = makeErr;
-		this.#error = error;
-		this.#resolved = resolved;
-		Object.freeze(this);
-	}
-	static fromResult(result, makeErr) {
-		if (result.isOk()) return new ErrMatchBuilder(makeErr, void 0, result);
-		if (result.isErr()) return new ErrMatchBuilder(makeErr, result.error);
-		throw new InvalidResultStateError("ErrMatchBuilder.fromResult");
-	}
-	when(ctor, handler) {
-		if (this.#resolved) return this;
-		if (this.#error instanceof ctor) {
-			const out = handler(this.#error);
-			const resolved = isResult$1(out) ? out : this.#makeErr(out);
-			return new ErrMatchBuilder(this.#makeErr, this.#error, resolved);
-		}
-		return this;
-	}
-	whenGuard(guard, handler) {
-		if (this.#resolved) return this;
-		const error = this.#error;
-		if (guard(error)) {
-			const out = handler(error);
-			const resolved = isResult$1(out) ? out : this.#makeErr(out);
-			return new ErrMatchBuilder(this.#makeErr, this.#error, resolved);
-		}
-		return this;
-	}
-	otherwise(handler) {
-		if (this.#resolved) return this.#resolved;
-		const out = handler(this.#error);
-		return isResult$1(out) ? out : this.#makeErr(out);
-	}
-	run() {
-		if (this.#resolved) return this.#resolved;
-		throw this.#error;
-	}
-};
-
-//#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));
-		return source;
-	};
-}
-
-//#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));
-		return source;
-	};
-}
-
-//#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 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);
-		return source;
-	};
-}
-
-//#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 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);
-	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/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() && observer.ok) observer.ok(source.value);
-		if (source.isErr() && observer.err) observer.err(source.error);
-		return source;
-	};
-}
-
-//#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());
-		}
-		return source;
-	};
-}
-
-//#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 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 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 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 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);
-		}
-	};
-}
+import { A as flatMap, B as isResult, C as tryCatch, D as match, E as recoverWith, F as combine, I as zip, L as all, M as mapBoth, N as mapErr, O as filter, P as map, R as sequence, S as tryMap, T as recover, _ as tapAsync, a as fromNullable, b as mapAsync, c as ok, d as tryAsync, f as tryFn, g as filterAsync, h as matchAsync, i as err, j as bimap, k as tap, l as okIf, m as tryCatchAsync, n as Ok, o as fromPromise, p as tryMapAsync, r as Result, s as fromThrowable, t as Err, u as okIfLazy, v as flatMapAsync, w as swap, x as collectFirstOk, y as mapErrAsync, z as matchTag } from "./result-DKKaNdOx.mjs";
+import { _ as TaskYieldNotResultError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultTypeError, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as UnwrapErrOnOkError, y as UnwrapOnErrError } from "./errors-2WOswg7r.mjs";
+import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B0_4r6Jn.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-C6Y9hx79.mjs";
 
-//#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;
-		try {
-			if (source.isOk()) return ok(project(source.value));
-			throw new InvalidResultStateError("tryMap");
-		} 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 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));
-		return source;
-	};
-}
-
-//#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));
-		return source;
-	};
-}
-
-//#endregion
-//#region src/core/flatMapAsync.ts
-/**
-* Async version of flatMap.
-*/
-function flatMapAsync(project) {
-	return async (source) => {
-		if (source.isOk()) return await project(source.value);
-		return source;
-	};
-}
-
-//#endregion
-//#region src/core/tapAsync.ts
-/**
-* Async version of tap.
-*/
-function tapAsync(observer) {
-	return async (source) => {
-		if (source.isOk() && observer.ok) await observer.ok(source.value);
-		if (source.isErr() && observer.err) await observer.err(source.error);
-		return source;
-	};
-}
-
-//#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());
-		}
-		return source;
-	};
-}
-
-//#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 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;
-		try {
-			if (source.isOk()) return ok(await project(source.value));
-			throw new InvalidResultStateError("tryMapAsync");
-		} catch (error) {
-			return err(errorMapper ? errorMapper(error) : error);
-		}
-	};
-}
-
-//#endregion
-//#region src/core/result.ts
-var ResultBase = class extends Pipeable {
-	isOk() {
-		return this._tag === "Ok";
-	}
-	isErr() {
-		return this._tag === "Err";
-	}
-	unwrapOr(defaultValue) {
-		return this._tag === "Ok" ? this.value : defaultValue;
-	}
-	/**
-	* 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 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;
-	}
-	/**
-	* 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()) { ... }`.
-	*/
-	match() {
-		if (this._tag === "Err") return new ErrorMatchBuilder(this.error);
-		throw new MatchOnOkError();
-	}
-	/**
-	* Matches on the Err value, but normalizes every branch to a `Result`:
-	* - Handlers may return a `Result` (is returned directly)
-	* - or an Error value (is wrapped into `Err(error)`)
-	*/
-	matchErr() {
-		const makeErr = (error) => err(error);
-		return ErrMatchBuilder.fromResult(this, makeErr);
-	}
-	/**
-	* Serializes the Result into a simple object format.
-	* Preserves the original types.
-	*/
-	serialize() {
-		if (this._tag === "Ok") return {
-			isSuccess: true,
-			data: this.value
-		};
-		return {
-			isSuccess: false,
-			error: this.error
-		};
-	}
-	/**
-	* Serializes the Result into a user-friendly format.
-	* Converts Errors to readable strings.
-	*/
-	toUserFriendly() {
-		if (this._tag === "Ok") return {
-			isSuccess: true,
-			data: this.value
-		};
-		const error = this.error;
-		return {
-			isSuccess: false,
-			error: error && typeof error === "object" && "message" in error ? error.message : String(error)
-		};
-	}
-};
-var Ok = class extends ResultBase {
-	_tag = "Ok";
-	value;
-	error = void 0;
-	constructor(value) {
-		super();
-		this.value = value;
-		Object.freeze(this);
-	}
-};
-var Err = class extends ResultBase {
-	_tag = "Err";
-	value = void 0;
-	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) {
-		try {
-			return err(errorMapper ? errorMapper(error) : error);
-		} catch (mapperError) {
-			return err(mapperError);
-		}
-	}
-}
-function tryFn(fn) {
-	try {
-		return ok(fn());
-	} catch (error) {
-		return err(error);
-	}
-}
-const Result = {
-	ok,
-	err,
-	fromNullable,
-	fromPromise,
-	try: tryFn
-};
-
-//#endregion
-//#region src/core/isResult.ts
-/**
-* Checks whether a value is a Result.
-* Pure function alternative for runtime checks.
-*/
-function isResult(value) {
-	return typeof value === "object" && value !== null && "isOk" in value && typeof value.isOk === "function" && "isErr" in value && typeof value.isErr === "function";
-}
-
-//#endregion
 //#region src/gen.ts
 async function task(makeGenerator, onThrow) {
 	const iterator = makeGenerator();
@@ -714,38 +43,6 @@ async function task(makeGenerator, onThrow) {
 }
 const gen = task;
 
-//#endregion
-//#region src/core/fold.ts
-/**
-* Folds the Result into a single value by applying one of two functions.
-* The end of the pipe.
-*
-* This is the pipe operator equivalent of the `.fold()` instance method.
-*/
-function fold(handlers) {
-	return (source) => {
-		if (source.isOk()) return handlers.ok(source.value);
-		if (source.isErr()) return handlers.err(source.error);
-		throw new InvalidResultStateError("fold");
-	};
-}
-
-//#endregion
-//#region src/core/foldAsync.ts
-/**
-* Async version of `fold`. Folds the Result into a single value asynchronously.
-* The end of the pipe.
-*
-* This is the async pipe operator equivalent of the `.fold()` instance method.
-*/
-function foldAsync(handlers) {
-	return async (source) => {
-		if (source.isOk()) return await handlers.ok(source.value);
-		if (source.isErr()) return await handlers.err(source.error);
-		throw new InvalidResultStateError("foldAsync");
-	};
-}
-
 //#endregion
 //#region src/core/unwrap.ts
 /**
@@ -766,7 +63,8 @@ function unwrap(result) {
 */
 function unwrapOr(result, defaultValue) {
 	if (result.isOk()) return result.value;
-	return defaultValue;
+	if (result.isErr()) return defaultValue;
+	throw new InvalidResultStateError("unwrapOr");
 }
 
 //#endregion
@@ -823,7 +121,8 @@ function unwrapErr(result) {
 */
 function expectResult(result, message) {
 	if (result.isOk()) return result.value;
-	throw new ExpectOkError(message);
+	if (result.isErr()) throw new ExpectOkError(message);
+	throw new InvalidResultStateError("expectResult");
 }
 
 //#endregion
@@ -834,224 +133,8 @@ function expectResult(result, message) {
 */
 function expectErr(result, message) {
 	if (result.isErr()) return result.error;
-	throw new ExpectErrError(message);
-}
-
-//#endregion
-//#region src/core/and.ts
-/**
-* Combines two Results. Returns the second one only if the first is Ok.
-* Corresponds to Rust `and`.
-*/
-function and(result, other) {
-	return result.isOk() ? other : result;
-}
-
-//#endregion
-//#region src/core/or.ts
-/**
-* Fallback to another Result if the first is Err.
-* Corresponds to Rust `or`.
-*/
-function or(result, other) {
-	return result.isOk() ? result : other;
-}
-
-//#endregion
-//#region src/core/orElse.ts
-/**
-* Fallback with a function that returns a Result.
-* Corresponds to Rust `or_else`.
-*/
-function orElse(result, fn) {
-	if (result.isOk()) return result;
-	if (result.isErr()) return fn(result.error);
-	throw new InvalidResultStateError("orElse");
-}
-
-//#endregion
-//#region src/core/mapOr.ts
-/**
-* Transforms the value or returns a default value.
-* Corresponds to Rust `map_or`.
-*/
-function mapOr(result, defaultValue, fn) {
-	if (result.isOk()) return fn(result.value);
-	return defaultValue;
-}
-
-//#endregion
-//#region src/core/mapOrElse.ts
-/**
-* Transforms the value or calculates a default value using a function.
-* Corresponds to Rust `map_or_else`.
-*/
-function mapOrElse(result, defaultFn, fn) {
-	if (result.isOk()) return fn(result.value);
-	if (result.isErr()) return defaultFn(result.error);
-	throw new InvalidResultStateError("mapOrElse");
-}
-
-//#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 InvalidResultStateError("sequence");
-	}
-	return ok(values);
-}
-/**
-* Alias for `sequence`.
-*/
-function all(results) {
-	return sequence(results);
-}
-
-//#endregion
-//#region src/core/sequenceRecord.ts
-/**
-* Like `sequence`, but for Records/Objects.
-* Short-circuits on the first Err.
-*/
-function sequenceRecord(record) {
-	const out = {};
-	for (const key of Object.keys(record)) {
-		const result = record[key];
-		if (!result) continue;
-		if (result.isOk()) {
-			out[key] = result.value;
-			continue;
-		}
-		if (result.isErr()) return result;
-		throw new InvalidResultStateError("sequenceRecord");
-	}
-	return ok(out);
-}
-
-//#endregion
-//#region src/core/collectFirstOkAsync.ts
-/**
-* Async version of collectFirstOk.
-*
-* - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
-* - Processes inputs strictly sequentially (like `for ... of` + `await`).
-* - Returns the first `Ok` and collects all errors if no `Ok` is found.
-*/
-async function collectFirstOkAsync(inputs) {
-	const errors = [];
-	for (const input of inputs) try {
-		const result = await (typeof input === "function" ? input() : input);
-		if (result.isOk()) return ok(result.value);
-		if (result.isErr()) {
-			errors.push(result.error);
-			continue;
-		}
-		throw new InvalidResultStateError("collectFirstOkAsync");
-	} catch (error) {
-		errors.push(error);
-	}
-	return err(errors);
-}
-
-//#endregion
-//#region src/core/collectFirstOkParallelAsync.ts
-/**
-* Parallel version of `collectFirstOkAsync`.
-*
-* - Starts all inputs immediately (Promises or Thunks).
-* - Returns the first `Ok` as soon as it is available.
-* - If no `Ok` is found, returns an `Err` with all error values (in input order).
-* - Rejections are treated as `ErrValue` (`caught as ErrValue`).
-* - If multiple inputs provide an `Ok`, the one that completes first wins.
-*   In case of simultaneous completion, the first observed result wins.
-* - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
-*/
-async function collectFirstOkParallelAsync(inputs) {
-	if (inputs.length === 0) return err([]);
-	const started = inputs.map((input) => typeof input === "function" ? Promise.resolve().then(input) : input);
-	const firstOk = new Promise((resolve) => {
-		for (const promise of started) promise.then((result) => {
-			if (result.isOk()) resolve(ok(result.value));
-		}).catch(() => {});
-	});
-	const allErrors = Promise.allSettled(started).then((settled) => {
-		const errors = [];
-		for (const entry of settled) if (entry.status === "fulfilled") {
-			const result = entry.value;
-			if (result.isErr()) errors.push(result.error);
-			else if (!result.isOk()) errors.push(new InvalidResultStateError("collectFirstOkParallelAsync"));
-		} else errors.push(entry.reason);
-		return err(errors);
-	});
-	return Promise.race([firstOk, allErrors]);
-}
-
-//#endregion
-//#region src/core/collectAllErrors.ts
-/**
-* Combines a list of Results.
-* Return Ok(values) only if all are Ok, otherwise Err([errors]).
-*/
-function collectAllErrors(results) {
-	const values = [];
-	const errors = [];
-	for (const result of results) {
-		if (result.isOk()) {
-			values.push(result.value);
-			continue;
-		}
-		if (result.isErr()) {
-			errors.push(result.error);
-			continue;
-		}
-		throw new InvalidResultStateError("collectAllErrors");
-	}
-	return errors.length === 0 ? ok(values) : err(errors);
-}
-
-//#endregion
-//#region src/core/partition.ts
-/**
-* Partitions Results into Ok values and Err errors.
-*/
-function partition(results) {
-	const oks = [];
-	const errs = [];
-	for (const result of results) {
-		if (result.isOk()) {
-			oks.push(result.value);
-			continue;
-		}
-		if (result.isErr()) {
-			errs.push(result.error);
-			continue;
-		}
-		throw new InvalidResultStateError("partition");
-	}
-	return [oks, errs];
-}
-
-//#endregion
-//#region src/core/flatten.ts
-/**
-* Flattens a nested Result.
-* Result<Result<T, E>, E> → Result<T, E>
-* Corresponds to Rust `flatten`.
-*/
-function flatten(result) {
-	if (result.isOk()) return result.value;
-	return result;
+	if (result.isOk()) throw new ExpectErrError(message);
+	throw new InvalidResultStateError("expectErr");
 }
 
 //#endregion
@@ -1074,7 +157,8 @@ function toPromise(result) {
 */
 function toNullable(result) {
 	if (result.isOk()) return result.value;
-	return null;
+	if (result.isErr()) return null;
+	throw new InvalidResultStateError("toNullable");
 }
 
 //#endregion
@@ -1084,7 +168,9 @@ function toNullable(result) {
 * Pure function alternative to the instance method.
 */
 function isOk(result) {
-	return result.isOk();
+	if (result.isOk()) return true;
+	if (result.isErr()) return false;
+	throw new InvalidResultStateError("isOk");
 }
 
 //#endregion
@@ -1094,7 +180,9 @@ function isOk(result) {
 * Pure function alternative to the instance method.
 */
 function isErr(result) {
-	return result.isErr();
+	if (result.isErr()) return true;
+	if (result.isOk()) return false;
+	throw new InvalidResultStateError("isErr");
 }
 
 //#endregion
@@ -1104,8 +192,9 @@ function isErr(result) {
 * Corresponds to Rust `contains`.
 */
 function contains(result, value) {
-	if (!result.isOk()) return false;
-	return result.value === value;
+	if (result.isOk()) return result.value === value;
+	if (result.isErr()) return false;
+	throw new InvalidResultStateError("contains");
 }
 
 //#endregion
@@ -1115,10 +204,11 @@ function contains(result, value) {
 * Analogous to `contains` for the Err case.
 */
 function containsErr(result, error) {
-	if (!result.isErr()) return false;
-	return result.error === error;
+	if (result.isErr()) return result.error === error;
+	if (result.isOk()) return false;
+	throw new InvalidResultStateError("containsErr");
 }
 
 //#endregion
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_STATE, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchOnOkError, Ok, Result, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, Ok, Result, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, fromThrowable, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, matchTag, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryAsync, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
 //# sourceMappingURL=index.mjs.map