@shirudo/result 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1499 @@
+//#region src/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/utils/isResult.ts
+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/matcher.ts
+/**
+* Matcher for Err values (returns any return type, e.g. string messages).
+*
+* - `.when(Ctor, handler)` matched via `instanceof`
+* - `.whenGuard(guard, handler)` matched via type guard
+* - `.run()` is only allowed once all error cases are handled (`E` is 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;
+	}
+};
+/**
+* Matcher for `Result` errors that always returns a `Result`.
+*
+* Handlers may:
+* - return a `Result` (returned directly)
+* - return an error value (automatically wrapped to `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 Error("Unreachable: Result is neither Ok nor Err");
+	}
+	when(ctor, handler) {
+		if (this.#resolved) return this;
+		if (this.#error instanceof ctor) {
+			const out = handler(this.#error);
+			const resolved = isResult(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(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(out) ? out : this.#makeErr(out);
+	}
+	run() {
+		if (this.#resolved) return this.#resolved;
+		throw this.#error;
+	}
+};
+/**
+* Universal matcher for `Result` (Ok + Err in a single chain).
+*
+* - `.err(Ctor, handler)` matched via `instanceof`
+* - `.errVal(value, handler)` matched via `Object.is`
+* - `.ok(handler)` defines the success branch
+* - `.run()` is only allowed after `.ok()` is set
+*
+* Lazy: if the Result is `Ok`, Err cases are not evaluated in `.run()`.
+*/
+var ResultMatchBuilder = class ResultMatchBuilder {
+	#result;
+	#errCases;
+	#okHandler;
+	constructor(result, errCases = [], okHandler) {
+		this.#result = result;
+		this.#errCases = Object.freeze([...errCases]);
+		this.#okHandler = okHandler;
+		Object.freeze(this);
+	}
+	static fromResult(result) {
+		return new ResultMatchBuilder(result);
+	}
+	err(ctor, handler) {
+		return new ResultMatchBuilder(this.#result, [...this.#errCases, {
+			kind: "ctor",
+			ctor,
+			handler
+		}], this.#okHandler);
+	}
+	errVal(value, handler) {
+		return new ResultMatchBuilder(this.#result, [...this.#errCases, {
+			kind: "val",
+			value,
+			handler
+		}], this.#okHandler);
+	}
+	ok(handler) {
+		return new ResultMatchBuilder(this.#result, this.#errCases, handler);
+	}
+	run() {
+		const result = this.#result;
+		if (result.isOk()) {
+			const okHandler = this.#okHandler;
+			if (!okHandler) throw new Error("ResultMatchBuilder.run() requires an ok() handler.");
+			return okHandler(result.value);
+		}
+		if (result.isErr()) {
+			const error = result.error;
+			for (const c of this.#errCases) {
+				if (c.kind === "ctor") {
+					if (error instanceof c.ctor) return c.handler(error);
+					continue;
+				}
+				if (Object.is(error, c.value)) return c.handler(error);
+			}
+			throw error;
+		}
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	}
+};
+
+//#endregion
+//#region src/conversions/fromNullable.ts
+/**
+* Converts `null | undefined` to `Err`, everything else to `Ok`.
+* 
+* **Type Safety**: The type assertion `as NonNullable<T>` is safe,
+* as the runtime check guarantees that the value is not null/undefined.
+* 
+* @param value The value to check
+* @param error The error to use if value is null/undefined
+* @returns An Ok Result with the NonNullable value, or an Err Result with the error
+* 
+* @example
+* ```ts
+* fromNullable(user, 'User not found')
+* // Ok(user) or Err('User not found')
+* ```
+*/
+function fromNullable(value, error) {
+	if (value === null || value === void 0) return Result.err(error);
+	return Result.ok(value);
+}
+
+//#endregion
+//#region src/conversions/fromPromise.ts
+async function fromPromise(promise, errorMapper) {
+	try {
+		const value = await promise;
+		return Result.ok(value);
+	} catch (error) {
+		try {
+			return Result.err(errorMapper ? errorMapper(error) : error);
+		} catch (mapperError) {
+			return Result.err(mapperError);
+		}
+	}
+}
+
+//#endregion
+//#region src/conversions/try.ts
+/**
+* Executes a function and catches exceptions.
+* 
+* @param fn The function to execute
+* @returns An Ok Result with the return value, or an Err Result with the caught exception
+* 
+* @example
+* ```ts
+* const result = tryFn(() => JSON.parse(input));
+* // Ok(parsed) or Err(SyntaxError)
+* ```
+*/
+function tryFn(fn) {
+	try {
+		return Result.ok(fn());
+	} catch (error) {
+		return Result.err(error);
+	}
+}
+
+//#endregion
+//#region src/conversions/toPromise.ts
+/**
+* Converts a Result to a Promise.
+* Ok → resolves with the value, Err → rejects with the error
+* 
+* @param result The Result to convert
+* @returns A Promise that resolves with the value if Ok, or rejects with the error if Err
+* 
+* @example
+* ```ts
+* const result = ok(42);
+* const promise = toPromise(result);
+* const value = await promise; // 42
+* ```
+*/
+function toPromise(result) {
+	if (result.isOk()) return Promise.resolve(result.value);
+	return Promise.reject(result.error);
+}
+
+//#endregion
+//#region src/conversions/toNullable.ts
+/**
+* Converts a Result to `T | null`.
+* Ok → returns the value, Err → returns null
+* 
+* @param result The Result to convert
+* @returns The value if Ok, or null if Err
+* 
+* @example
+* ```ts
+* const result = ok(42);
+* const value = toNullable(result); // 42
+* 
+* const errResult = err('error');
+* const nullValue = toNullable(errResult); // null
+* ```
+*/
+function toNullable(result) {
+	if (result.isOk()) return result.value;
+	return null;
+}
+
+//#endregion
+//#region src/result.ts
+var Result = class Result extends Pipeable {
+	#state;
+	constructor(state) {
+		super();
+		Object.freeze(state);
+		this.#state = state;
+		Object.freeze(this);
+	}
+	/**
+	* Creates an Ok Result with the given value.
+	* 
+	* **Note**: `null` and `undefined` are allowed as values.
+	* If you want to convert `null`/`undefined` to an Err, use `fromNullable()`.
+	* 
+	* @param value The value for the Ok Result
+	* @returns An Ok Result with the given value
+	* 
+	* @example
+	* ```ts
+	* const result = Result.ok(42);
+	* const nullResult = Result.ok(null); // Allowed!
+	* ```
+	*/
+	static ok(value) {
+		return new Result({
+			_tag: "Ok",
+			value
+		});
+	}
+	/**
+	* Creates an Err Result with the given error.
+	* 
+	* **Note**: `null` and `undefined` are allowed as errors.
+	* 
+	* @param error The error for the Err Result
+	* @returns An Err Result with the given error
+	* 
+	* @example
+	* ```ts
+	* const result = Result.err('error message');
+	* const nullError = Result.err(null); // Allowed!
+	* ```
+	*/
+	static err(error) {
+		return new Result({
+			_tag: "Err",
+			error
+		});
+	}
+	/**
+	* Converts `null | undefined` to `Err`, everything else to `Ok`.
+	* 
+	* **Type Safety**: The type assertion `as NonNullable<T>` is safe,
+	* as the runtime check guarantees that the value is not null/undefined.
+	* 
+	* @param value The value to check
+	* @param error The error to use if value is null/undefined
+	* @returns An Ok Result with the NonNullable value, or an Err Result with the error
+	* 
+	* @example
+	* ```ts
+	* Result.fromNullable(user, 'User not found')
+	* // Ok(user) or Err('User not found')
+	* ```
+	*/
+	static fromNullable(value, error) {
+		return fromNullable(value, error);
+	}
+	static fromPromise(promise, errorMapper) {
+		return fromPromise(promise, errorMapper);
+	}
+	/**
+	* Executes a function and catches exceptions.
+	* 
+	* @example
+	* ```ts
+	* const result = Result.try(() => JSON.parse(input));
+	* // Ok(parsed) or Err(SyntaxError)
+	* ```
+	*/
+	static try(fn) {
+		return tryFn(fn);
+	}
+	/**
+	* Checks if the Result is Ok.
+	* 
+	* @returns `true` if the Result is Ok (and narrows the type)
+	* 
+	* @example
+	* ```ts
+	* if (result.isOk()) {
+	*   const value: T = result.value; // TypeScript knows that value is defined
+	* }
+	* ```
+	*/
+	isOk() {
+		return this.#state._tag === "Ok";
+	}
+	/**
+	* Checks if the Result is Err.
+	* 
+	* @returns `true` if the Result is Err (and narrows the type)
+	* 
+	* @example
+	* ```ts
+	* if (result.isErr()) {
+	*   const error: E = result.error; // TypeScript knows that error is defined
+	* }
+	* ```
+	*/
+	isErr() {
+		return this.#state._tag === "Err";
+	}
+	get value() {
+		return this.#state._tag === "Ok" ? this.#state.value : void 0;
+	}
+	get error() {
+		return this.#state._tag === "Err" ? this.#state.error : void 0;
+	}
+	/**
+	* Returns the value, guaranteed to be defined after `isOk()` check.
+	* This method provides better type narrowing than the `value` getter.
+	* 
+	* ⚠️ **Warning**: This method throws an Error if called on an Err result.
+	* Use this method only after a type guard (`if (result.isOk())`).
+	* For a safer alternative with a custom message, use `expect()`.
+	* 
+	* @throws {Error} If called on an Err result
+	* 
+	* @example
+	* ```ts
+	* if (result.isOk()) {
+	*   const value = result.unwrap(); // Type is T, not T | undefined
+	* }
+	* ```
+	*/
+	unwrap() {
+		if (this.#state._tag === "Ok") return this.#state.value;
+		const errorStr = (() => {
+			try {
+				const error = this.#state.error;
+				if (error === null) return "null";
+				if (error === void 0) return "undefined";
+				if (typeof error === "string") return error;
+				if (error instanceof Error) return error.message;
+				if (typeof error === "object" && "toString" in error) try {
+					return String(error);
+				} catch {
+					return "[unstringifiable error]";
+				}
+				return String(error);
+			} catch {
+				return "[unstringifiable error]";
+			}
+		})();
+		throw new Error(`Called unwrap() on Err: ${errorStr}`);
+	}
+	/**
+	* Returns the error, guaranteed to be defined after `isErr()` check.
+	* This method provides better type narrowing than the `error` getter.
+	* 
+	* ⚠️ **Warning**: This method throws an Error if called on an Ok result.
+	* Use this method only after a type guard (`if (result.isErr())`).
+	* For a safer alternative with a custom message, use `expectErr()`.
+	* 
+	* @throws {Error} If called on an Ok result
+	* 
+	* @example
+	* ```ts
+	* if (result.isErr()) {
+	*   const error = result.unwrapErr(); // Type is E, not E | undefined
+	* }
+	* ```
+	*/
+	unwrapErr() {
+		if (this.#state._tag === "Err") return this.#state.error;
+		const valueStr = (() => {
+			try {
+				const value = this.#state.value;
+				if (value === null) return "null";
+				if (value === void 0) return "undefined";
+				if (typeof value === "string") return value;
+				if (value instanceof Error) return value.message;
+				if (typeof value === "object" && "toString" in value) try {
+					return String(value);
+				} catch {
+					return "[unstringifiable value]";
+				}
+				return String(value);
+			} catch {
+				return "[unstringifiable value]";
+			}
+		})();
+		throw new Error(`Called unwrapErr() on Ok: ${valueStr}`);
+	}
+	/**
+	* Returns the value with a custom error message if the result is Err.
+	* Similar to `unwrap()`, but allows you to provide a custom error message.
+	* 
+	* ⚠️ **Warning**: This method throws an Error if called on an Err result.
+	* Use this method only if you are sure the Result is Ok,
+	* or if you need a meaningful error message.
+	* 
+	* @param message Custom error message to throw if result is Err
+	* @returns The value if result is Ok
+	* @throws {Error} If called on an Err result with the provided message
+	* 
+	* @example
+	* ```ts
+	* const result = fetchUser(id);
+	* const user = result.expect('User should exist'); // Throws with custom message if Err
+	* ```
+	*/
+	expect(message) {
+		if (this.#state._tag === "Ok") return this.#state.value;
+		throw new Error(message);
+	}
+	/**
+	* Returns the error with a custom error message if the result is Ok.
+	* Similar to `unwrapErr()`, but allows you to provide a custom error message.
+	* 
+	* ⚠️ **Warning**: This method throws an Error if called on an Ok result.
+	* Use this method only if you are sure the Result is Err,
+	* or if you need a meaningful error message.
+	* 
+	* @param message Custom error message to throw if result is Ok
+	* @returns The error if result is Err
+	* @throws {Error} If called on an Ok result with the provided message
+	* 
+	* @example
+	* ```ts
+	* const result = validateInput(input);
+	* if (result.isErr()) {
+	*   const error = result.expectErr('Validation should have failed'); // Throws if Ok
+	* }
+	* ```
+	*/
+	expectErr(message) {
+		if (this.#state._tag === "Err") return this.#state.error;
+		throw new Error(message);
+	}
+	unwrapOr(defaultValue) {
+		return this.#state._tag === "Ok" ? this.#state.value : defaultValue;
+	}
+	/**
+	* Converts the Result to a Promise.
+	* Ok → resolves with the value, Err → rejects with the error
+	* 
+	* This instance method delegates to the standalone `toPromise()` function.
+	* 
+	* @returns A Promise that resolves with the value if Ok, or rejects with the error if Err
+	* 
+	* @example
+	* ```ts
+	* const result = ok(42);
+	* const promise = result.toPromise();
+	* const value = await promise; // 42
+	* 
+	* const errResult = err('error');
+	* try {
+	*   await errResult.toPromise();
+	* } catch (error) {
+	*   console.log(error); // 'error'
+	* }
+	* ```
+	*/
+	toPromise() {
+		return toPromise(this);
+	}
+	/**
+	* Converts the Result to `T | null`.
+	* Ok → returns the value, Err → returns null
+	* 
+	* This instance method delegates to the standalone `toNullable()` function.
+	* 
+	* @returns The value if Ok, or null if Err
+	* 
+	* @example
+	* ```ts
+	* const result = ok(42);
+	* const value = result.toNullable(); // 42
+	* 
+	* const errResult = err('error');
+	* const nullValue = errResult.toNullable(); // null
+	* ```
+	*/
+	toNullable() {
+		return toNullable(this);
+	}
+	/**
+	* 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;
+	}
+	/**
+	* Universal pattern matcher for Ok + Err cases.
+	* 
+	* Use this to exhaustively match on both success and error cases with type-based
+	* and value-based pattern matching.
+	* 
+	* @example
+	* ```ts
+	* const message = result
+	*   .match()
+	*   .err(NetworkError, e => `Network: ${e.message}`)
+	*   .err(ValidationError, e => `Validation: ${e.message}`)
+	*   .ok(val => `Success: ${val}`)
+	*   .run();
+	* ```
+	*/
+	match() {
+		return ResultMatchBuilder.fromResult(this);
+	}
+	matchErr() {
+		if (this.isErr()) return new ErrorMatchBuilder(this.error);
+		throw new Error("matchErr() can only be called on Err results. Use `if (result.isErr()) { ... }` first.");
+	}
+	/**
+	* Matches on the Err value, but normalizes every branch to a `Result`:
+	* - Handlers may return a `Result` (returned directly)
+	* - or an error value (wrapped to `Err(error)`)
+	*/
+	matchErrResult() {
+		const makeErr = (error) => Result.err(error);
+		return ErrMatchBuilder.fromResult(this, makeErr);
+	}
+	/**
+	* @deprecated Use `.match()` instead. Will be removed in next major version.
+	*/
+	pattern() {
+		return this.match();
+	}
+	/**
+	* @deprecated Use `.match()` instead. Will be removed in next major version.
+	*/
+	switch() {
+		return this.match();
+	}
+	/**
+	* Folds the Result into a single value by applying one of two functions.
+	* 
+	* This is a direct method equivalent to the `match` pipe operator.
+	* Use this when you want to handle both Ok and Err cases and return a single value.
+	* 
+	* @param onOk Function to apply if the Result is Ok
+	* @param onErr Function to apply if the Result is Err
+	* @returns The result of applying the appropriate function
+	* 
+	* @example
+	* ```ts
+	* const result = ok(42);
+	* const message = result.fold(
+	*     val => `Success: ${val}`,
+	*     err => `Error: ${err}`
+	* );
+	* // message = "Success: 42"
+	* ```
+	* 
+	* @example
+	* ```ts
+	* // Works with discriminated unions
+	* const result: Result<string, number> = err(404);
+	* const response = result.fold(
+	*     data => ({ success: true as const, data }),
+	*     code => ({ success: false as const, code })
+	* );
+	* // response: { success: true; data: string } | { success: false; code: number }
+	* ```
+	*/
+	fold(onOk, onErr) {
+		if (this.isOk()) return onOk(this.value);
+		if (this.isErr()) return onErr(this.error);
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	}
+	/**
+	* Returns the Result as a discriminated union (`{ _tag: 'Ok', value } | { _tag: 'Err', error }`).
+	* Useful for libraries like `ts-pattern` that match on plain object unions.
+	*/
+	toUnion() {
+		return this.#state;
+	}
+	/**
+	* Serializes the Result into a simple object format.
+	* Preserves the original types.
+	*/
+	serialize() {
+		if (this.#state._tag === "Ok") return {
+			isSuccess: true,
+			data: this.#state.value
+		};
+		return {
+			isSuccess: false,
+			error: this.#state.error
+		};
+	}
+	/**
+	* Serializes the Result into a user-friendly format.
+	* Converts errors to readable strings.
+	*/
+	toUserFriendly() {
+		if (this.#state._tag === "Ok") return {
+			isSuccess: true,
+			data: this.#state.value
+		};
+		const error = this.#state.error;
+		const toSafeString = (value) => {
+			try {
+				return String(value);
+			} catch {
+				return "[Unstringifiable error]";
+			}
+		};
+		return {
+			isSuccess: false,
+			error: (() => {
+				if (error && typeof error === "object" && "message" in error) {
+					const message = error.message;
+					return typeof message === "string" ? message : toSafeString(error);
+				}
+				return toSafeString(error);
+			})()
+		};
+	}
+};
+const ok = Result.ok;
+const err = Result.err;
+/**
+* Helper for conditional Result creation.
+* Avoids type inference issues with ternary operators.
+* 
+* @example
+* ```ts
+* const result = okIf(value > 5, value, 'too small');
+* // instead of: value > 5 ? ok(value) : err('too small')
+* ```
+*/
+function okIf(condition, okValue, errValue) {
+	return condition ? ok(okValue) : err(errValue);
+}
+/**
+* Helper for conditional Result creation with lazy evaluation.
+* Evaluates values only when they are needed.
+* 
+* @example
+* ```ts
+* const result = okIfLazy(
+*     value > 5,
+*     () => expensiveComputation(value),
+*     () => 'too small'
+* );
+* ```
+*/
+function okIfLazy(condition, okFn, errFn) {
+	return condition ? ok(okFn()) : err(errFn());
+}
+
+//#endregion
+//#region src/gen.ts
+async function task(makeGenerator, onThrow) {
+	const iterator = makeGenerator();
+	let input = void 0;
+	while (true) {
+		let step;
+		try {
+			step = await iterator.next(input);
+		} catch (caught) {
+			if (!onThrow) throw caught;
+			return err(onThrow(caught));
+		}
+		if (step.done) try {
+			const awaited = await step.value;
+			if (isResult(awaited)) return awaited;
+			return ok(awaited);
+		} catch (caught) {
+			if (!onThrow) throw caught;
+			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 (yielded.isOk()) {
+			input = yielded.value;
+			continue;
+		}
+		if (yielded.isErr()) {
+			try {
+				if (typeof iterator.return === "function") await iterator.return(void 0);
+			} catch (caught) {
+				if (!onThrow) throw caught;
+				return err(onThrow(caught));
+			}
+			return yielded;
+		}
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	}
+}
+const gen = task;
+
+//#endregion
+//#region src/operators/map.ts
+/**
+* Transforms the value (Ok case).
+* Equivalent to Rust `map`.
+*/
+function map(project) {
+	return (source) => {
+		if (source.isOk()) return ok(project(source.value));
+		return source;
+	};
+}
+
+//#endregion
+//#region src/operators/mapErr.ts
+/**
+* Transforms the error (Err case).
+* Equivalent to Rust `map_err`.
+*/
+function mapErr(project) {
+	return (source) => {
+		if (source.isErr()) return err(project(source.error));
+		return source;
+	};
+}
+
+//#endregion
+//#region src/operators/mapBoth.ts
+/**
+* Transforms both the Ok value and the Err error.
+* Equivalent 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");
+	};
+}
+/**
+* Alias for `mapBoth`.
+*/
+const bimap = mapBoth;
+
+//#endregion
+//#region src/operators/flatMap.ts
+/**
+* Chains another operation that returns a Result.
+* Equivalent to Rust `and_then` or JS `flatMap`.
+*/
+function flatMap(project) {
+	return (source) => {
+		if (source.isOk()) return project(source.value);
+		return source;
+	};
+}
+
+//#endregion
+//#region src/operators/tap.ts
+/**
+* Executes a side effect (logging, debugging) without changing the Result.
+* Equivalent 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/operators/filter.ts
+/**
+* Checks a predicate. If false, the Result becomes Err.
+* Partially equivalent to Rust `filter`.
+*/
+function filter(predicate, errorFn) {
+	return (source) => {
+		if (source.isOk()) {
+			if (predicate(source.value)) return source;
+			return err(errorFn());
+		}
+		return source;
+	};
+}
+
+//#endregion
+//#region src/operators/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 Error("Unreachable: Result is neither Ok nor Err");
+	};
+}
+/**
+* @deprecated Use `fold` instead. Will be removed in next major version.
+*/
+const match = fold;
+
+//#endregion
+//#region src/operators/tryCatch.ts
+/**
+* Executes a function and catches exceptions.
+* Converts exceptions into Result<E>.
+* Equivalent 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/operators/tryMap.ts
+/**
+* Like `map`, but catches exceptions and turns them into 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");
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/operators/recover.ts
+/**
+* Recover: turns Err into Ok(defaultValue).
+* Result is guaranteed 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");
+	};
+}
+/**
+* Like `recover`, but computes the default value from 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");
+	};
+}
+
+//#endregion
+//#region src/operators-async/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/operators-async/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/operators-async/flatMapAsync.ts
+/**
+* Async version of flatMap.
+* Allows different error types in the projected Result.
+*/
+function flatMapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return await project(source.value);
+		return source;
+	};
+}
+
+//#endregion
+//#region src/operators-async/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/operators-async/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/operators-async/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 Error("Unreachable: Result is neither Ok nor Err");
+	};
+}
+/**
+* @deprecated Use `foldAsync` instead. Will be removed in next major version.
+*/
+const matchAsync = foldAsync;
+
+//#endregion
+//#region src/operators-async/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/operators-async/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 Error("Unreachable: Result is neither Ok nor Err");
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/unwrap/unwrap.ts
+/**
+* Returns the value or throws an Error.
+* Equivalent 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");
+}
+
+//#endregion
+//#region src/unwrap/unwrapOr.ts
+/**
+* Returns the value or a default value.
+* Pure function alternative to the instance method.
+*/
+function unwrapOr(result, defaultValue) {
+	if (result.isOk()) return result.value;
+	return defaultValue;
+}
+
+//#endregion
+//#region src/unwrap/unwrapOrElse.ts
+/**
+* Returns the value or computes a default value with a function.
+* Equivalent 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");
+}
+
+//#endregion
+//#region src/unwrap/unwrapOrDefault.ts
+/**
+* Alias for `unwrapOr`.
+* Equivalent to Rust `unwrap_or_default` (with an explicit default value).
+*/
+function unwrapOrDefault(result, defaultValue) {
+	return unwrapOr(result, defaultValue);
+}
+
+//#endregion
+//#region src/unwrap/unwrapOrThrow.ts
+/**
+* Returns the value or throws the original Err value (not wrapped).
+* Useful to keep `Error` instances with 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");
+}
+
+//#endregion
+//#region src/unwrap/unwrapErr.ts
+/**
+* Returns the error or throws an Error.
+* Equivalent 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");
+}
+
+//#endregion
+//#region src/unwrap/expectResult.ts
+/**
+* Returns the value or throws an Error with a custom message.
+* Equivalent to Rust `expect`.
+*/
+function expectResult(result, message) {
+	if (result.isOk()) return result.value;
+	throw new Error(message);
+}
+
+//#endregion
+//#region src/unwrap/expectErr.ts
+/**
+* Returns the error or throws an Error with a custom message.
+* Equivalent to Rust `expect_err`.
+*/
+function expectErr(result, message) {
+	if (result.isErr()) return result.error;
+	throw new Error(message);
+}
+
+//#endregion
+//#region src/combinators/and.ts
+/**
+* Combines two Results. Returns the second only if the first is Ok.
+* Equivalent to Rust `and`.
+*/
+function and(result, other) {
+	return result.isOk() ? other : result;
+}
+
+//#endregion
+//#region src/combinators/or.ts
+/**
+* Fallback to another Result when the first is Err.
+* Equivalent to Rust `or`.
+*/
+function or(result, other) {
+	return result.isOk() ? result : other;
+}
+
+//#endregion
+//#region src/combinators/orElse.ts
+/**
+* Fallback using a function that returns a Result.
+* Equivalent 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");
+}
+
+//#endregion
+//#region src/combinators/mapOr.ts
+/**
+* Transforms the value or returns a default value.
+* Equivalent to Rust `map_or`.
+*/
+function mapOr(result, defaultValue, fn) {
+	if (result.isOk()) return fn(result.value);
+	return defaultValue;
+}
+
+//#endregion
+//#region src/combinators/mapOrElse.ts
+/**
+* Transforms the value or computes a default value with a function.
+* Equivalent 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");
+}
+
+//#endregion
+//#region src/combinators/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 Error("Unreachable: Result is neither Ok nor Err");
+}
+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/combinators/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 Error("Unreachable: Result is neither Ok nor Err");
+}
+
+//#endregion
+//#region src/collections/sequence.ts
+/**
+* Combines a list of Results into a 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 Error("Unreachable: Result is neither Ok nor Err");
+	}
+	return ok(values);
+}
+/**
+* Alias for `sequence`.
+*/
+function all(results) {
+	return sequence(results);
+}
+
+//#endregion
+//#region src/collections/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) throw new Error(`Missing Result for key "${String(key)}"`);
+		if (result.isOk()) {
+			out[key] = result.value;
+			continue;
+		}
+		if (result.isErr()) return result;
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	}
+	return ok(out);
+}
+
+//#endregion
+//#region src/collections/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 Error("Unreachable: Result is neither Ok nor Err");
+	}
+	return err(errors);
+}
+
+//#endregion
+//#region src/collections/collectFirstOkAsync.ts
+/**
+* Async version of collectFirstOk.
+*
+* - Accepts already-started promises or "thunks" (`() => Awaitable<Result<...>>`).
+* - Processes inputs strictly sequentially (like `for ... of` + `await`).
+* - Returns the first `Ok` and collects all errors when 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 Error("Unreachable: Result is neither Ok nor Err");
+	} catch (error) {
+		errors.push(error);
+	}
+	return err(errors);
+}
+
+//#endregion
+//#region src/collections/collectFirstOkRaceAsync.ts
+/**
+* Parallel/race variant 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).
+* - **Note**: There is no cancellation logic. All inputs keep running even after the first `Ok` is found.
+*/
+async function collectFirstOkRaceAsync(inputs) {
+	if (inputs.length === 0) return err([]);
+	const UNSET = Symbol("unset");
+	const errorsByIndex = Array(inputs.length).fill(UNSET);
+	return new Promise((resolve) => {
+		let done = false;
+		let remaining = inputs.length;
+		const finishAllErr = () => {
+			const errors = [];
+			for (const entry of errorsByIndex) if (entry !== UNSET) errors.push(entry);
+			resolve(err(errors));
+		};
+		const settleError = (index, errorValue) => {
+			if (done) return;
+			errorsByIndex[index] = errorValue;
+			remaining -= 1;
+			if (remaining === 0) {
+				done = true;
+				finishAllErr();
+			}
+		};
+		inputs.forEach((input, index) => {
+			Promise.resolve().then(() => typeof input === "function" ? input() : input).then((result) => {
+				if (done) return;
+				if (result.isOk()) {
+					done = true;
+					resolve(ok(result.value));
+					return;
+				}
+				if (result.isErr()) {
+					settleError(index, result.error);
+					return;
+				}
+				settleError(index, /* @__PURE__ */ new Error("Unreachable: Result is neither Ok nor Err"));
+			}).catch((caught) => {
+				settleError(index, caught);
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/collections/collectAllErrors.ts
+/**
+* Combines a list of Results.
+* Returns 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 Error("Unreachable: Result is neither Ok nor Err");
+	}
+	return errors.length === 0 ? ok(values) : err(errors);
+}
+
+//#endregion
+//#region src/collections/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 Error("Unreachable: Result is neither Ok nor Err");
+	}
+	return [oks, errs];
+}
+
+//#endregion
+//#region src/collections/flatten.ts
+/**
+* Flacht ein nested Result ab.
+* Result<Result<T, E>, E> → Result<T, E>
+* Entspricht Rust `flatten`.
+*/
+function flatten(result) {
+	if (result.isOk()) return result.value;
+	return result;
+}
+
+//#endregion
+//#region src/utils/isOk.ts
+/**
+* Checks whether a Result is Ok.
+* Pure function alternative to the instance method.
+*/
+function isOk(result) {
+	return result.isOk();
+}
+
+//#endregion
+//#region src/utils/isErr.ts
+/**
+* Checks whether a Result is Err.
+* Pure function alternative to the instance method.
+*/
+function isErr(result) {
+	return result.isErr();
+}
+
+//#endregion
+//#region src/utils/contains.ts
+/**
+* Checks whether the Result contains a specific value.
+* Equivalent to Rust `contains`.
+*/
+function contains(result, value) {
+	if (!result.isOk()) return false;
+	return result.value === value;
+}
+
+//#endregion
+//#region src/utils/containsErr.ts
+/**
+* Checks whether the Result contains a specific error.
+* Analogous to `contains` for the Err case.
+*/
+function containsErr(result, error) {
+	if (!result.isErr()) return false;
+	return result.error === error;
+}
+
+//#endregion
+export { Result, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkRaceAsync, 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 };
+//# sourceMappingURL=index.mjs.map