@shirudo/result 0.0.5 → 1.0.0

package/dist/index.cjs

@@ -1,680 +1,8 @@
+const require_result = require('./result-CY-KIivk.cjs');
+const require_errors = require('./errors-D2EMzJQl.cjs');
+const require_mapOrElse = require('./mapOrElse-H-GvAUka.cjs');
+const require_flatten = require('./flatten-Df9U40nO.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/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);
-		}
-	};
-}
-
-//#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();
@@ -685,18 +13,18 @@ async function task(makeGenerator, onThrow) {
 			step = await iterator.next(input);
 		} catch (caught) {
 			if (!onThrow) throw caught;
-			return err(onThrow(caught));
+			return require_result.err(onThrow(caught));
 		}
 		if (step.done) try {
 			const awaited = await step.value;
-			if (isResult(awaited)) return awaited;
-			return ok(awaited);
+			if (require_result.isResult(awaited)) return awaited;
+			return require_result.ok(awaited);
 		} catch (caught) {
 			if (!onThrow) throw caught;
-			return err(onThrow(caught));
+			return require_result.err(onThrow(caught));
 		}
 		const yielded = step.value;
-		if (!isResult(yielded)) throw new TaskYieldNotResultError(yielded);
+		if (!require_result.isResult(yielded)) throw new require_errors.TaskYieldNotResultError(yielded);
 		if (yielded.isOk()) {
 			input = yielded.value;
 			continue;
@@ -706,47 +34,15 @@ async function task(makeGenerator, onThrow) {
 				if (typeof iterator.return === "function") await iterator.return(void 0);
 			} catch (caught) {
 				if (!onThrow) throw caught;
-				return err(onThrow(caught));
+				return require_result.err(onThrow(caught));
 			}
 			return yielded;
 		}
-		throw new InvalidResultStateError("task");
+		throw new require_errors.InvalidResultStateError("task");
 	}
 }
 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
 /**
@@ -755,8 +51,8 @@ function foldAsync(handlers) {
 */
 function unwrap(result) {
 	if (result.isOk()) return result.value;
-	if (result.isErr()) throw new UnwrapOnErrError(result.error);
-	throw new InvalidResultStateError("unwrap");
+	if (result.isErr()) throw new require_errors.UnwrapOnErrError(result.error);
+	throw new require_errors.InvalidResultStateError("unwrap");
 }
 
 //#endregion
@@ -767,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 require_errors.InvalidResultStateError("unwrapOr");
 }
 
 //#endregion
@@ -779,7 +76,7 @@ function unwrapOr(result, defaultValue) {
 function unwrapOrElse(result, fn) {
 	if (result.isOk()) return result.value;
 	if (result.isErr()) return fn(result.error);
-	throw new InvalidResultStateError("unwrapOrElse");
+	throw new require_errors.InvalidResultStateError("unwrapOrElse");
 }
 
 //#endregion
@@ -801,7 +98,7 @@ function unwrapOrDefault(result, defaultValue) {
 function unwrapOrThrow(result) {
 	if (result.isOk()) return result.value;
 	if (result.isErr()) throw result.error;
-	throw new InvalidResultStateError("unwrapOrThrow");
+	throw new require_errors.InvalidResultStateError("unwrapOrThrow");
 }
 
 //#endregion
@@ -812,8 +109,8 @@ function unwrapOrThrow(result) {
 */
 function unwrapErr(result) {
 	if (result.isErr()) return result.error;
-	if (result.isOk()) throw new UnwrapErrOnOkError(result.value);
-	throw new InvalidResultStateError("unwrapErr");
+	if (result.isOk()) throw new require_errors.UnwrapErrOnOkError(result.value);
+	throw new require_errors.InvalidResultStateError("unwrapErr");
 }
 
 //#endregion
@@ -824,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 require_errors.ExpectOkError(message);
+	throw new require_errors.InvalidResultStateError("expectResult");
 }
 
 //#endregion
@@ -835,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 require_errors.ExpectErrError(message);
+	throw new require_errors.InvalidResultStateError("expectErr");
 }
 
 //#endregion
@@ -1064,7 +146,7 @@ function flatten(result) {
 function toPromise(result) {
 	if (result.isOk()) return Promise.resolve(result.value);
 	if (result.isErr()) return Promise.reject(result.error);
-	throw new InvalidResultStateError("toPromise");
+	throw new require_errors.InvalidResultStateError("toPromise");
 }
 
 //#endregion
@@ -1075,7 +157,8 @@ function toPromise(result) {
 */
 function toNullable(result) {
 	if (result.isOk()) return result.value;
-	return null;
+	if (result.isErr()) return null;
+	throw new require_errors.InvalidResultStateError("toNullable");
 }
 
 //#endregion
@@ -1085,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 require_errors.InvalidResultStateError("isOk");
 }
 
 //#endregion
@@ -1095,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 require_errors.InvalidResultStateError("isErr");
 }
 
 //#endregion
@@ -1105,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 require_errors.InvalidResultStateError("contains");
 }
 
 //#endregion
@@ -1116,91 +204,98 @@ function contains(result, value) {
 * Analogous to `contains` for the Err case.
 */
 function containsErr(result, error) {
-	if (!result.isErr()) return false;
-	return result.error === error;
-}
-
-//#endregion
-exports.ERR_EXPECT_ERR = ERR_EXPECT_ERR;
-exports.ERR_EXPECT_OK = ERR_EXPECT_OK;
-exports.ERR_INVALID_STATE = ERR_INVALID_STATE;
-exports.ERR_MATCH_ON_OK = ERR_MATCH_ON_OK;
-exports.ERR_TASK_YIELD_NOT_RESULT = ERR_TASK_YIELD_NOT_RESULT;
-exports.ERR_UNWRAP_ERR_ON_OK = ERR_UNWRAP_ERR_ON_OK;
-exports.ERR_UNWRAP_ON_ERR = ERR_UNWRAP_ON_ERR;
-exports.Err = Err;
-exports.ExpectErrError = ExpectErrError;
-exports.ExpectOkError = ExpectOkError;
-exports.InvalidResultStateError = InvalidResultStateError;
-exports.MatchOnOkError = MatchOnOkError;
-exports.Ok = Ok;
-exports.Result = Result;
-exports.ResultError = ResultError;
-exports.ResultTypeError = ResultTypeError;
-exports.TaskYieldNotResultError = TaskYieldNotResultError;
-exports.UnwrapErrOnOkError = UnwrapErrOnOkError;
-exports.UnwrapOnErrError = UnwrapOnErrError;
-exports.all = all;
-exports.and = and;
-exports.bimap = bimap;
-exports.collectAllErrors = collectAllErrors;
-exports.collectFirstOk = collectFirstOk;
-exports.collectFirstOkAsync = collectFirstOkAsync;
-exports.collectFirstOkParallelAsync = collectFirstOkParallelAsync;
-exports.combine = combine;
+	if (result.isErr()) return result.error === error;
+	if (result.isOk()) return false;
+	throw new require_errors.InvalidResultStateError("containsErr");
+}
+
+//#endregion
+exports.ERR_EXPECT_ERR = require_errors.ERR_EXPECT_ERR;
+exports.ERR_EXPECT_OK = require_errors.ERR_EXPECT_OK;
+exports.ERR_INVALID_RESULT_STATE = require_errors.ERR_INVALID_RESULT_STATE;
+exports.ERR_INVALID_STATE = require_errors.ERR_INVALID_STATE;
+exports.ERR_MATCH_ERR_HANDLER_NOT_RESULT = require_errors.ERR_MATCH_ERR_HANDLER_NOT_RESULT;
+exports.ERR_MATCH_ON_OK = require_errors.ERR_MATCH_ON_OK;
+exports.ERR_TASK_YIELD_NOT_RESULT = require_errors.ERR_TASK_YIELD_NOT_RESULT;
+exports.ERR_UNWRAP_ERR_ON_OK = require_errors.ERR_UNWRAP_ERR_ON_OK;
+exports.ERR_UNWRAP_ON_ERR = require_errors.ERR_UNWRAP_ON_ERR;
+exports.Err = require_result.Err;
+exports.ExpectErrError = require_errors.ExpectErrError;
+exports.ExpectOkError = require_errors.ExpectOkError;
+exports.InvalidResultStateError = require_errors.InvalidResultStateError;
+exports.MatchErrHandlerNotResultError = require_errors.MatchErrHandlerNotResultError;
+exports.MatchOnOkError = require_errors.MatchOnOkError;
+exports.Ok = require_result.Ok;
+exports.Result = require_result.Result;
+exports.ResultError = require_errors.ResultError;
+exports.ResultTypeError = require_errors.ResultTypeError;
+exports.TaskYieldNotResultError = require_errors.TaskYieldNotResultError;
+exports.UnwrapErrOnOkError = require_errors.UnwrapErrOnOkError;
+exports.UnwrapOnErrError = require_errors.UnwrapOnErrError;
+exports.all = require_result.all;
+exports.and = require_mapOrElse.and;
+exports.bimap = require_result.bimap;
+exports.collectAllErrors = require_flatten.collectAllErrors;
+exports.collectFirstOk = require_result.collectFirstOk;
+exports.collectFirstOkAsync = require_flatten.collectFirstOkAsync;
+exports.collectFirstOkParallelAsync = require_flatten.collectFirstOkParallelAsync;
+exports.combine = require_result.combine;
 exports.contains = contains;
 exports.containsErr = containsErr;
-exports.err = err;
+exports.err = require_result.err;
 exports.expectErr = expectErr;
 exports.expectResult = expectResult;
-exports.filter = filter;
-exports.filterAsync = filterAsync;
-exports.flatMap = flatMap;
-exports.flatMapAsync = flatMapAsync;
-exports.flatten = flatten;
-exports.fold = fold;
-exports.foldAsync = foldAsync;
-exports.fromNullable = fromNullable;
-exports.fromPromise = fromPromise;
+exports.filter = require_result.filter;
+exports.filterAsync = require_result.filterAsync;
+exports.flatMap = require_result.flatMap;
+exports.flatMapAsync = require_result.flatMapAsync;
+exports.flatten = require_flatten.flatten;
+exports.fold = require_mapOrElse.fold;
+exports.foldAsync = require_mapOrElse.foldAsync;
+exports.fromNullable = require_result.fromNullable;
+exports.fromPromise = require_result.fromPromise;
+exports.fromThrowable = require_result.fromThrowable;
 exports.gen = gen;
 exports.isErr = isErr;
 exports.isOk = isOk;
-exports.isResult = isResult;
-exports.map = map;
-exports.mapAsync = mapAsync;
-exports.mapBoth = mapBoth;
-exports.mapErr = mapErr;
-exports.mapErrAsync = mapErrAsync;
-exports.mapOr = mapOr;
-exports.mapOrElse = mapOrElse;
-exports.match = match;
-exports.matchAsync = matchAsync;
-exports.ok = ok;
-exports.okIf = okIf;
-exports.okIfLazy = okIfLazy;
-exports.or = or;
-exports.orElse = orElse;
-exports.partition = partition;
-exports.recover = recover;
-exports.recoverWith = recoverWith;
-exports.sequence = sequence;
-exports.sequenceRecord = sequenceRecord;
-exports.swap = swap;
-exports.tap = tap;
-exports.tapAsync = tapAsync;
+exports.isResult = require_result.isResult;
+exports.map = require_result.map;
+exports.mapAsync = require_result.mapAsync;
+exports.mapBoth = require_result.mapBoth;
+exports.mapErr = require_result.mapErr;
+exports.mapErrAsync = require_result.mapErrAsync;
+exports.mapOr = require_mapOrElse.mapOr;
+exports.mapOrElse = require_mapOrElse.mapOrElse;
+exports.match = require_result.match;
+exports.matchAsync = require_result.matchAsync;
+exports.matchTag = require_result.matchTag;
+exports.ok = require_result.ok;
+exports.okIf = require_result.okIf;
+exports.okIfLazy = require_result.okIfLazy;
+exports.or = require_mapOrElse.or;
+exports.orElse = require_mapOrElse.orElse;
+exports.partition = require_flatten.partition;
+exports.recover = require_result.recover;
+exports.recoverWith = require_result.recoverWith;
+exports.sequence = require_result.sequence;
+exports.sequenceRecord = require_flatten.sequenceRecord;
+exports.swap = require_result.swap;
+exports.tap = require_result.tap;
+exports.tapAsync = require_result.tapAsync;
 exports.task = task;
 exports.toNullable = toNullable;
 exports.toPromise = toPromise;
-exports.tryCatch = tryCatch;
-exports.tryCatchAsync = tryCatchAsync;
-exports.tryFn = tryFn;
-exports.tryMap = tryMap;
-exports.tryMapAsync = tryMapAsync;
+exports.tryAsync = require_result.tryAsync;
+exports.tryCatch = require_result.tryCatch;
+exports.tryCatchAsync = require_result.tryCatchAsync;
+exports.tryFn = require_result.tryFn;
+exports.tryMap = require_result.tryMap;
+exports.tryMapAsync = require_result.tryMapAsync;
 exports.unwrap = unwrap;
 exports.unwrapErr = unwrapErr;
 exports.unwrapOr = unwrapOr;
 exports.unwrapOrDefault = unwrapOrDefault;
 exports.unwrapOrElse = unwrapOrElse;
 exports.unwrapOrThrow = unwrapOrThrow;
-exports.zip = zip;
+exports.zip = require_result.zip;
 //# sourceMappingURL=index.cjs.map