@shirudo/result 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -13,14 +13,96 @@ var Pipeable = class {
 	}
 };
 
+//#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 für Err-Values (liefert einen beliebigen Return-Type, z.B. string messages).
+* Matcher for Err values (returns an arbitrary return type, e.g. string messages).
 *
-* - `.when(Ctor, handler)` matched via `instanceof`
-* - `.whenGuard(guard, handler)` matched via Type-Guard
-* - `.run()` ist nur erlaubt, wenn alle Error-Cases behandelt wurden (`E` wurde zu `never` reduziert)
+* - `.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;
@@ -56,11 +138,11 @@ 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 für `Result`-Errors, der immer wieder ein `Result` zurückgibt.
+* Matcher for `Result` Errors, which returns a `Result` again.
 *
-* Handler dürfen:
-* - ein `Result` zurückgeben (wird direkt returned)
-* - einen Error-Wert zurückgeben (wird automatisch zu `Err(error)` gewrappt)
+* Handlers may:
+* - return a `Result` (is returned directly)
+* - return an Error value (is automatically wrapped into `Err(error)`)
 */
 var ErrMatchBuilder = class ErrMatchBuilder {
 	#makeErr;
@@ -75,7 +157,7 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 	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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("ErrMatchBuilder.fromResult");
 	}
 	when(ctor, handler) {
 		if (this.#resolved) return this;
@@ -110,8 +192,8 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 //#endregion
 //#region src/core/map.ts
 /**
-* Transformiert den Wert (Ok-Fall).
-* Entspricht Rust `map`.
+* Transforms the value (Ok case).
+* Corresponds to Rust `map`.
 */
 function map(project) {
 	return (source) => {
@@ -123,8 +205,8 @@ function map(project) {
 //#endregion
 //#region src/core/mapErr.ts
 /**
-* Transformiert den Fehler (Err-Fall).
-* Entspricht Rust `map_err`.
+* Transforms the error (Err case).
+* Corresponds to Rust `map_err`.
 */
 function mapErr(project) {
 	return (source) => {
@@ -136,26 +218,26 @@ function mapErr(project) {
 //#endregion
 //#region src/core/mapBoth.ts
 /**
-* Transformiert sowohl den Ok-Wert als auch den Err-Fehler.
-* Entspricht FP `bimap` / `mapBoth`.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("mapBoth");
 	};
 }
 /**
-* Alias für `mapBoth`.
+* Alias for `mapBoth`.
 */
 const bimap = mapBoth;
 
 //#endregion
 //#region src/core/flatMap.ts
 /**
-* Verkettet eine weitere Operation, die ein Result zurückgibt.
-* Entspricht Rust `and_then` oder JS `flatMap`.
+* Chains another operation that returns a Result.
+* Corresponds to Rust `and_then` or JS `flatMap`.
 */
 function flatMap(project) {
 	return (source) => {
@@ -170,7 +252,7 @@ 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 Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("zip");
 }
 function zip(...args) {
 	if (args.length === 1) {
@@ -199,8 +281,8 @@ function combine(...args) {
 //#endregion
 //#region src/core/tap.ts
 /**
-* Führt einen Seiteneffekt aus (Logging, Debugging), ohne das Result zu ändern.
-* Entspricht Rust `inspect` / `inspect_err`.
+* Executes a side effect (logging, debugging) without changing the Result.
+* Corresponds to Rust `inspect` / `inspect_err`.
 */
 function tap(observer) {
 	return (source) => {
@@ -213,8 +295,8 @@ function tap(observer) {
 //#endregion
 //#region src/core/filter.ts
 /**
-* Prüft eine Bedingung. Wenn falsch, wird das Result zu Err.
-* Entspricht Rust `filter` (teilweise).
+* Checks a condition. If false, the Result becomes Err.
+* Corresponds to Rust `filter` (partially).
 */
 function filter(predicate, errorFn) {
 	return (source) => {
@@ -229,59 +311,59 @@ function filter(predicate, errorFn) {
 //#endregion
 //#region src/core/match.ts
 /**
-* Löst das Result auf. Das Ende der Pipe.
-* Entspricht Rust `match`.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("match");
 	};
 }
 
 //#endregion
 //#region src/core/recover.ts
 /**
-* Recover: wandelt Err in Ok(defaultValue) um.
-* Ergebnis ist garantiert Ok → Error-Typ wird `never`.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("recover");
 	};
 }
 /**
-* Wie `recover`, aber berechnet den Default-Wert anhand des Errors.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("recoverWith");
 	};
 }
 
 //#endregion
 //#region src/core/swap.ts
 /**
-* Tauscht Ok und Err.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("swap");
 }
 
 //#endregion
 //#region src/core/tryCatch.ts
 /**
-* Führt eine Funktion aus und fängt Exceptions ab.
-* Wandelt Exceptions in Result<E> um.
-* Entspricht Rust `Result::from` für fallible Operationen.
+* 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) => {
@@ -297,14 +379,14 @@ function tryCatch(fn, errorMapper) {
 //#endregion
 //#region src/core/tryMap.ts
 /**
-* Wie `map`, aber fängt Exceptions ab und wandelt sie in Err um.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+			throw new InvalidResultStateError("tryMap");
 		} catch (error) {
 			return err(errorMapper ? errorMapper(error) : error);
 		}
@@ -326,7 +408,7 @@ function collectFirstOk(results) {
 			errors.push(result.error);
 			continue;
 		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("collectFirstOk");
 	}
 	return err(errors);
 }
@@ -334,7 +416,7 @@ function collectFirstOk(results) {
 //#endregion
 //#region src/core/mapAsync.ts
 /**
-* Async-Version von map.
+* Async version of map.
 */
 function mapAsync(project) {
 	return async (source) => {
@@ -346,7 +428,7 @@ function mapAsync(project) {
 //#endregion
 //#region src/core/mapErrAsync.ts
 /**
-* Async-Version von mapErr.
+* Async version of mapErr.
 */
 function mapErrAsync(project) {
 	return async (source) => {
@@ -358,7 +440,7 @@ function mapErrAsync(project) {
 //#endregion
 //#region src/core/flatMapAsync.ts
 /**
-* Async-Version von flatMap.
+* Async version of flatMap.
 */
 function flatMapAsync(project) {
 	return async (source) => {
@@ -370,7 +452,7 @@ function flatMapAsync(project) {
 //#endregion
 //#region src/core/tapAsync.ts
 /**
-* Async-Version von tap.
+* Async version of tap.
 */
 function tapAsync(observer) {
 	return async (source) => {
@@ -383,7 +465,7 @@ function tapAsync(observer) {
 //#endregion
 //#region src/core/filterAsync.ts
 /**
-* Async-Version von filter.
+* Async version of filter.
 */
 function filterAsync(predicate, errorFn) {
 	return async (source) => {
@@ -398,20 +480,20 @@ function filterAsync(predicate, errorFn) {
 //#endregion
 //#region src/core/matchAsync.ts
 /**
-* Async-Version von match.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("matchAsync");
 	};
 }
 
 //#endregion
 //#region src/core/tryCatchAsync.ts
 /**
-* Async-Version von tryCatch.
+* Async version of tryCatch.
 */
 function tryCatchAsync(fn, errorMapper) {
 	return async (source) => {
@@ -427,14 +509,14 @@ function tryCatchAsync(fn, errorMapper) {
 //#endregion
 //#region src/core/tryMapAsync.ts
 /**
-* Async-Version von tryMap.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+			throw new InvalidResultStateError("tryMapAsync");
 		} catch (error) {
 			return err(errorMapper ? errorMapper(error) : error);
 		}
@@ -459,7 +541,7 @@ var ResultBase = class extends Pipeable {
 	fold(onOk, onErr) {
 		if (this._tag === "Ok") return onOk(this.value);
 		if (this._tag === "Err") return onErr(this.error);
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("Result.fold");
 	}
 	/**
 	* Enables `yield* result` in generators (Do-notation).
@@ -472,27 +554,27 @@ var ResultBase = class extends Pipeable {
 		return yield this;
 	}
 	/**
-	* Matcht auf den Err-Wert via `.when(...)` Kette.
+	* Matches on the Err value via `.when(...)` chain.
 	*
-	* Hinweis: aus Type-Safety-Gründen ist `.match()` nur auf einem bereits zu `Err` verengten Result aufrufbar,
-	* z.B. innerhalb von `if (result.isErr()) { ... }`.
+	* 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 Error("match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.");
+		throw new MatchOnOkError();
 	}
 	/**
-	* Matcht auf den Err-Wert, aber normalisiert jeden Branch zu einem `Result`:
-	* - Handler dürfen ein `Result` zurückgeben (wird direkt returned)
-	* - oder einen Error-Wert (wird zu `Err(error)` gewrappt)
+	* 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);
 	}
 	/**
-	* Serialisiert das Result in ein einfaches Objekt-Format.
-	* Behält die ursprünglichen Typen bei.
+	* Serializes the Result into a simple object format.
+	* Preserves the original types.
 	*/
 	serialize() {
 		if (this._tag === "Ok") return {
@@ -505,8 +587,8 @@ var ResultBase = class extends Pipeable {
 		};
 	}
 	/**
-	* Serialisiert das Result in ein user-friendly Format.
-	* Konvertiert Errors zu lesbaren Strings.
+	* Serializes the Result into a user-friendly format.
+	* Converts Errors to readable strings.
 	*/
 	toUserFriendly() {
 		if (this._tag === "Ok") return {
@@ -614,7 +696,7 @@ async function task(makeGenerator, onThrow) {
 			return err(onThrow(caught));
 		}
 		const yielded = step.value;
-		if (!isResult(yielded)) throw new TypeError("task() expected yielded values to be Result. Use `yield*` on a Result.");
+		if (!isResult(yielded)) throw new TaskYieldNotResultError(yielded);
 		if (yielded.isOk()) {
 			input = yielded.value;
 			continue;
@@ -628,7 +710,7 @@ async function task(makeGenerator, onThrow) {
 			}
 			return yielded;
 		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("task");
 	}
 }
 const gen = task;
@@ -645,7 +727,7 @@ function fold(handlers) {
 	return (source) => {
 		if (source.isOk()) return handlers.ok(source.value);
 		if (source.isErr()) return handlers.err(source.error);
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("fold");
 	};
 }
 
@@ -661,27 +743,27 @@ 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 Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("foldAsync");
 	};
 }
 
 //#endregion
 //#region src/core/unwrap.ts
 /**
-* Gibt den Wert zurück oder wirft einen Error.
-* Entspricht Rust `unwrap`.
+* Returns the value or throws an Error.
+* Corresponds to Rust `unwrap`.
 */
 function unwrap(result) {
 	if (result.isOk()) return result.value;
-	if (result.isErr()) throw new Error(`Called unwrap() on Err: ${String(result.error)}`);
-	throw new Error("Unreachable: Result is neither Ok nor Err");
+	if (result.isErr()) throw new UnwrapOnErrError(result.error);
+	throw new InvalidResultStateError("unwrap");
 }
 
 //#endregion
 //#region src/core/unwrapOr.ts
 /**
-* Gibt den Wert zurück oder einen Default-Wert.
-* Pure function Alternative zur Instanz-Methode.
+* Returns the value or a default value.
+* Pure function alternative to the instance method.
 */
 function unwrapOr(result, defaultValue) {
 	if (result.isOk()) return result.value;
@@ -691,20 +773,20 @@ function unwrapOr(result, defaultValue) {
 //#endregion
 //#region src/core/unwrapOrElse.ts
 /**
-* Gibt den Wert zurück oder berechnet einen Default-Wert mit einer Funktion.
-* Entspricht Rust `unwrap_or_else`.
+* Returns the value or calculates a default value using a function.
+* Corresponds to Rust `unwrap_or_else`.
 */
 function unwrapOrElse(result, fn) {
 	if (result.isOk()) return result.value;
 	if (result.isErr()) return fn(result.error);
-	throw new Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("unwrapOrElse");
 }
 
 //#endregion
 //#region src/core/unwrapOrDefault.ts
 /**
-* Alias für `unwrapOr`.
-* Entspricht Rust `unwrap_or_default` (mit explizitem Default-Wert).
+* Alias for `unwrapOr`.
+* Corresponds to Rust `unwrap_or_default` (with explicit default value).
 */
 function unwrapOrDefault(result, defaultValue) {
 	return unwrapOr(result, defaultValue);
@@ -713,54 +795,54 @@ function unwrapOrDefault(result, defaultValue) {
 //#endregion
 //#region src/core/unwrapOrThrow.ts
 /**
-* Gibt den Wert zurück oder wirft den originalen Err-Wert (nicht gewrappt).
-* Nützlich um `Error`-Instanzen inkl. Stacktrace zu erhalten.
+* Returns the value or throws the original Err value (not wrapped).
+* Useful to preserve `Error` instances including stack traces.
 */
 function unwrapOrThrow(result) {
 	if (result.isOk()) return result.value;
 	if (result.isErr()) throw result.error;
-	throw new Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("unwrapOrThrow");
 }
 
 //#endregion
 //#region src/core/unwrapErr.ts
 /**
-* Gibt den Fehler zurück oder wirft einen Error.
-* Entspricht Rust `unwrap_err`.
+* Returns the error or throws an Error.
+* Corresponds to Rust `unwrap_err`.
 */
 function unwrapErr(result) {
 	if (result.isErr()) return result.error;
-	if (result.isOk()) throw new Error(`Called unwrapErr() on Ok: ${String(result.value)}`);
-	throw new Error("Unreachable: Result is neither Ok nor Err");
+	if (result.isOk()) throw new UnwrapErrOnOkError(result.value);
+	throw new InvalidResultStateError("unwrapErr");
 }
 
 //#endregion
 //#region src/core/expectResult.ts
 /**
-* Gibt den Wert zurück oder wirft einen Error mit custom Nachricht.
-* Entspricht Rust `expect`.
+* Returns the value or throws an Error with a custom message.
+* Corresponds to Rust `expect`.
 */
 function expectResult(result, message) {
 	if (result.isOk()) return result.value;
-	throw new Error(message);
+	throw new ExpectOkError(message);
 }
 
 //#endregion
 //#region src/core/expectErr.ts
 /**
-* Gibt den Fehler zurück oder wirft einen Error mit custom Nachricht.
-* Entspricht Rust `expect_err`.
+* Returns the error or throws an Error with a custom message.
+* Corresponds to Rust `expect_err`.
 */
 function expectErr(result, message) {
 	if (result.isErr()) return result.error;
-	throw new Error(message);
+	throw new ExpectErrError(message);
 }
 
 //#endregion
 //#region src/core/and.ts
 /**
-* Kombiniert zwei Results. Gibt den zweiten zurück nur wenn erster Ok ist.
-* Entspricht Rust `and`.
+* 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;
@@ -769,8 +851,8 @@ function and(result, other) {
 //#endregion
 //#region src/core/or.ts
 /**
-* Fallback zu einem anderen Result wenn erster Err ist.
-* Entspricht Rust `or`.
+* Fallback to another Result if the first is Err.
+* Corresponds to Rust `or`.
 */
 function or(result, other) {
 	return result.isOk() ? result : other;
@@ -779,20 +861,20 @@ function or(result, other) {
 //#endregion
 //#region src/core/orElse.ts
 /**
-* Fallback mit einer Funktion die ein Result zurückgibt.
-* Entspricht Rust `or_else`.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("orElse");
 }
 
 //#endregion
 //#region src/core/mapOr.ts
 /**
-* Transformiert den Wert oder gibt einen Default-Wert zurück.
-* Entspricht Rust `map_or`.
+* 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);
@@ -802,21 +884,21 @@ function mapOr(result, defaultValue, fn) {
 //#endregion
 //#region src/core/mapOrElse.ts
 /**
-* Transformiert den Wert oder berechnet einen Default-Wert mit einer Funktion.
-* Entspricht Rust `map_or_else`.
+* 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 Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("mapOrElse");
 }
 
 //#endregion
 //#region src/core/sequence.ts
 /**
-* Kombiniert eine Liste von Results zu einem Result einer Liste.
-* Short-circuits beim ersten Err.
-* Analog zu Rust `collect::<Result<Vec<_>, _>>()`.
+* 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 = [];
@@ -826,12 +908,12 @@ function sequence(results) {
 			continue;
 		}
 		if (result.isErr()) return result;
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("sequence");
 	}
 	return ok(values);
 }
 /**
-* Alias für `sequence`.
+* Alias for `sequence`.
 */
 function all(results) {
 	return sequence(results);
@@ -840,8 +922,8 @@ function all(results) {
 //#endregion
 //#region src/core/sequenceRecord.ts
 /**
-* Wie `sequence`, aber für Records/Objekte.
-* Short-circuits beim ersten Err.
+* Like `sequence`, but for Records/Objects.
+* Short-circuits on the first Err.
 */
 function sequenceRecord(record) {
 	const out = {};
@@ -853,7 +935,7 @@ function sequenceRecord(record) {
 			continue;
 		}
 		if (result.isErr()) return result;
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("sequenceRecord");
 	}
 	return ok(out);
 }
@@ -861,11 +943,11 @@ function sequenceRecord(record) {
 //#endregion
 //#region src/core/collectFirstOkAsync.ts
 /**
-* Async-Version von collectFirstOk.
+* Async version of collectFirstOk.
 *
-* - Nimmt entweder bereits gestartete Promises oder "Thunks" (`() => Awaitable<Result<...>>`).
-* - Verarbeitet die Inputs strikt sequentiell (wie `for ... of` + `await`).
-* - Gibt das erste `Ok` zurück und sammelt alle Errors wenn kein `Ok` gefunden wird.
+* - 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 = [];
@@ -876,7 +958,7 @@ async function collectFirstOkAsync(inputs) {
 			errors.push(result.error);
 			continue;
 		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("collectFirstOkAsync");
 	} catch (error) {
 		errors.push(error);
 	}
@@ -886,15 +968,15 @@ async function collectFirstOkAsync(inputs) {
 //#endregion
 //#region src/core/collectFirstOkParallelAsync.ts
 /**
-* Parallel-Variante von `collectFirstOkAsync`.
+* Parallel version of `collectFirstOkAsync`.
 *
-* - Startet alle Inputs sofort (Promises oder Thunks).
-* - Gibt das erste `Ok` zurück, sobald es verfügbar ist.
-* - Wenn kein `Ok` gefunden wird, gibt ein `Err` mit allen Error-Werten (in Input-Reihenfolge) zurück.
-* - Rejections werden als `ErrValue` behandelt (`caught as ErrValue`).
-* - Wenn mehrere Inputs ein `Ok` liefern, gewinnt das zuerst abgeschlossene Ergebnis.
-*   Bei gleichzeitiger Completion gewinnt das zuerst beobachtete Ergebnis.
-* - Wenn kein `Ok` kommt und mindestens ein Input nie settled, bleibt das Promise offen.
+* - 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([]);
@@ -909,7 +991,7 @@ async function collectFirstOkParallelAsync(inputs) {
 		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(/* @__PURE__ */ new Error("Unreachable: Result is neither Ok nor Err"));
+			else if (!result.isOk()) errors.push(new InvalidResultStateError("collectFirstOkParallelAsync"));
 		} else errors.push(entry.reason);
 		return err(errors);
 	});
@@ -919,8 +1001,8 @@ async function collectFirstOkParallelAsync(inputs) {
 //#endregion
 //#region src/core/collectAllErrors.ts
 /**
-* Kombiniert eine Liste von Results.
-* Gibt Ok(values) nur zurück wenn alle Ok sind, sonst Err([errors]).
+* Combines a list of Results.
+* Return Ok(values) only if all are Ok, otherwise Err([errors]).
 */
 function collectAllErrors(results) {
 	const values = [];
@@ -934,7 +1016,7 @@ function collectAllErrors(results) {
 			errors.push(result.error);
 			continue;
 		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("collectAllErrors");
 	}
 	return errors.length === 0 ? ok(values) : err(errors);
 }
@@ -942,7 +1024,7 @@ function collectAllErrors(results) {
 //#endregion
 //#region src/core/partition.ts
 /**
-* Partitioniert Results in Ok-Werte und Err-Fehler.
+* Partitions Results into Ok values and Err errors.
 */
 function partition(results) {
 	const oks = [];
@@ -956,7 +1038,7 @@ function partition(results) {
 			errs.push(result.error);
 			continue;
 		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
+		throw new InvalidResultStateError("partition");
 	}
 	return [oks, errs];
 }
@@ -964,9 +1046,9 @@ function partition(results) {
 //#endregion
 //#region src/core/flatten.ts
 /**
-* Flacht ein nested Result ab.
+* Flattens a nested Result.
 * Result<Result<T, E>, E> → Result<T, E>
-* Entspricht Rust `flatten`.
+* Corresponds to Rust `flatten`.
 */
 function flatten(result) {
 	if (result.isOk()) return result.value;
@@ -976,19 +1058,19 @@ function flatten(result) {
 //#endregion
 //#region src/core/toPromise.ts
 /**
-* Konvertiert ein Result zu einem Promise.
+* Converts a Result to a Promise.
 * Ok → resolve(value), Err → reject(error)
 */
 function toPromise(result) {
 	if (result.isOk()) return Promise.resolve(result.value);
 	if (result.isErr()) return Promise.reject(result.error);
-	throw new Error("Unreachable: Result is neither Ok nor Err");
+	throw new InvalidResultStateError("toPromise");
 }
 
 //#endregion
 //#region src/core/toNullable.ts
 /**
-* Konvertiert ein Result zu `T | null`.
+* Converts a Result to `T | null`.
 * Ok → value, Err → null
 */
 function toNullable(result) {
@@ -999,8 +1081,8 @@ function toNullable(result) {
 //#endregion
 //#region src/core/isOk.ts
 /**
-* Prüft ob ein Result Ok ist.
-* Pure function Alternative zur Instanz-Methode.
+* Checks if a Result is Ok.
+* Pure function alternative to the instance method.
 */
 function isOk(result) {
 	return result.isOk();
@@ -1009,8 +1091,8 @@ function isOk(result) {
 //#endregion
 //#region src/core/isErr.ts
 /**
-* Prüft ob ein Result Err ist.
-* Pure function Alternative zur Instanz-Methode.
+* Checks if a Result is Err.
+* Pure function alternative to the instance method.
 */
 function isErr(result) {
 	return result.isErr();
@@ -1019,8 +1101,8 @@ function isErr(result) {
 //#endregion
 //#region src/core/contains.ts
 /**
-* Prüft ob das Result einen bestimmten Wert enthält.
-* Entspricht Rust `contains`.
+* Checks if the Result contains a specific value.
+* Corresponds to Rust `contains`.
 */
 function contains(result, value) {
 	if (!result.isOk()) return false;
@@ -1030,8 +1112,8 @@ function contains(result, value) {
 //#endregion
 //#region src/core/containsErr.ts
 /**
-* Prüft ob das Result einen bestimmten Fehler enthält.
-* Analog zu `contains` für den Err-Fall.
+* Checks if the Result contains a specific error.
+* Analogous to `contains` for the Err case.
 */
 function containsErr(result, error) {
 	if (!result.isErr()) return false;
@@ -1039,9 +1121,25 @@ function containsErr(result, 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;