@shirudo/result 1.1.1 → 1.2.0

package/dist/index.mjs

@@ -1,17 +1,45 @@
-import { _ as matchTag, a as fromNullable, c as ok, d as tryAsync, f as tryFn, g as sequence, h as all, i as err, l as okIf, m as zip, n as Ok, o as fromPromise, p as combine, r as Result, s as fromThrowable, t as Err, u as okIfLazy, v as isResult } from "./result-q9Na2bGa.mjs";
-import { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError } from "./errors.mjs";
-import { C as tap, D as mapErr, E as mapBoth, O as map, S as filter, T as bimap, _ as recoverWith, a as or, b as match, c as tryCatchAsync, d as filterAsync, f as tapAsync, g as recover, h as mapAsync, i as orElse, l as matchAsync, m as mapErrAsync, n as mapOrElse, o as and, p as flatMapAsync, r as mapOr, s as tryMapAsync, t as swap, u as foldAsync, v as tryMap, w as flatMap, x as fold, y as tryCatch } from "./swap-CFD2g1cB.mjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-ChTL5BfA.mjs";
+import { _ as matchTag, a as fromNullable, c as ok, d as tryAsync, f as tryFn, g as sequence, h as all, i as err, l as okIf, m as zip, n as Ok, o as fromPromise, p as combine, r as Result, s as fromThrowable, t as Err, u as okIfLazy, v as isResult } from "./result-DQCpkuOJ.mjs";
+import { _ as ResultError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapErrOnOkError, c as ERR_TASK_YIELD_NOT_RESULT, d as ExpectErrError, f as ExpectOkError, g as MatchTagMissingHandlerError, h as MatchOnOkError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ERR_ON_OK, m as MatchErrHandlerNotResultError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as InvalidResultStateError, r as ERR_INVALID_RESULT_STATE, s as ERR_MATCH_TAG_MISSING_HANDLER, t as ERR_EXPECT_ERR, u as ERR_UNWRAP_ON_ERR, v as ResultTypeError, x as UnwrapOnErrError, y as TaskYieldNotResultError } from "./errors-MuakEcnM.mjs";
+import { and, bimap, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync } from "./operators.mjs";
+import { collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequenceRecord } from "./collections.mjs";
 
 //#region src/gen.ts
 async function task(makeGenerator, onThrow) {
 	const iterator = makeGenerator();
-	let input = void 0;
-	const runGeneratorReturn = async () => {
-		if (typeof iterator.return !== "function") return;
+	const decide = (yielded) => {
+		if (!isResult(yielded)) return {
+			kind: "throw",
+			error: new TaskYieldNotResultError(yielded)
+		};
+		if (yielded.isOk()) return {
+			kind: "continue",
+			input: yielded.value
+		};
+		if (yielded.isErr()) return {
+			kind: "return",
+			result: yielded
+		};
+		return {
+			kind: "throw",
+			error: new InvalidResultStateError("task")
+		};
+	};
+	const abandon = async (pending) => {
+		if (typeof iterator.return !== "function") return pending;
+		let completion = pending;
 		let step = await iterator.return(void 0);
-		while (!step.done) step = await iterator.next(void 0);
+		while (!step.done) {
+			const decision = decide(step.value);
+			if (decision.kind === "continue") {
+				step = await iterator.next(decision.input);
+				continue;
+			}
+			completion = decision;
+			step = await iterator.return(void 0);
+		}
+		return completion;
 	};
+	let input = void 0;
 	while (true) {
 		let step;
 		try {
@@ -28,36 +56,20 @@ async function task(makeGenerator, onThrow) {
 			if (!onThrow) throw caught;
 			return err(onThrow(caught));
 		}
-		const yielded = step.value;
-		if (!isResult(yielded)) {
-			try {
-				await runGeneratorReturn();
-			} catch (caught) {
-				if (!onThrow) throw caught;
-				return err(onThrow(caught));
-			}
-			throw new TaskYieldNotResultError(yielded);
-		}
-		if (yielded.isOk()) {
-			input = yielded.value;
+		const decision = decide(step.value);
+		if (decision.kind === "continue") {
+			input = decision.input;
 			continue;
 		}
-		if (yielded.isErr()) {
-			try {
-				await runGeneratorReturn();
-			} catch (caught) {
-				if (!onThrow) throw caught;
-				return err(onThrow(caught));
-			}
-			return yielded;
-		}
+		let completion;
 		try {
-			await runGeneratorReturn();
+			completion = await abandon(decision);
 		} catch (caught) {
 			if (!onThrow) throw caught;
 			return err(onThrow(caught));
 		}
-		throw new InvalidResultStateError("task");
+		if (completion.kind === "throw") throw completion.error;
+		return completion.result;
 	}
 }
 const gen = task;
@@ -168,11 +180,29 @@ function expectErr(result, message) {
 * by `Result.toSerialized()` and by `JSON.stringify` on a Result.
 *
 * Throws `InvalidResultStateError` for data that is not in that shape.
+*
+* @deprecated Rebuild the Result yourself after validating the payload:
+*
+* ```ts
+* const restored = parsed._tag === 'Ok' ? ok(parsed.value) : err(parsed.error);
+* ```
+*
+* `fromSerialized` only checks the envelope, the `_tag` discriminant plus the
+* absence of an own key of the other state, never the payload itself, while its
+* type parameters claim `T` and `E` for whatever `JSON.parse` returned. It
+* also throws for malformed input at exactly the boundary where a Result
+* should be returned. Validate foreign data with your schema tool and
+* then call `ok`/`err`; the shape is exported as `ResultType<T, E>`. This
+* function will be removed in 2.0.
 */
 function fromSerialized(data) {
-	if (data !== null && typeof data === "object") {
-		if (data._tag === "Ok" && "value" in data) return ok(data.value);
-		if (data._tag === "Err" && "error" in data) return err(data.error);
+	if (data !== null && typeof data === "object") try {
+		if (data._tag === "Ok" && !Object.hasOwn(data, "error")) return ok(data.value);
+		if (data._tag === "Err" && !Object.hasOwn(data, "value")) return err(data.error);
+	} catch (error) {
+		const invalid = new InvalidResultStateError("fromSerialized");
+		invalid.cause = error;
+		throw invalid;
 	}
 	throw new InvalidResultStateError("fromSerialized");
 }

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/gen.ts","../src/core/unwrap.ts","../src/core/unwrapOr.ts","../src/core/unwrapOrElse.ts","../src/core/unwrapOrDefault.ts","../src/core/unwrapOrThrow.ts","../src/core/unwrapErr.ts","../src/core/expectResult.ts","../src/core/expectErr.ts","../src/core/fromSerialized.ts","../src/core/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":["import type { Result } from './core/result';\nimport { err, ok } from './core/result';\nimport { isResult } from './core/isResult';\nimport { InvalidResultStateError, TaskYieldNotResultError } from './errors';\n\ntype AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturn<R> = Awaited<R>;\ntype OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;\ntype ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;\n\n/**\n * Generator-based do-notation for `Result`.\n *\n * Usage:\n * ```ts\n * const out = await task(async function* () {\n *   const user = yield* await fromPromise(findUser(1));\n *   const email = yield* validate(user.email);\n *   return email;\n * });\n * ```\n */\nexport async function task<const Y, const R>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> {\n    const iterator = makeGenerator();\n    let input: unknown = undefined;\n\n    // Resume the suspended generator as if it returned, so its `finally`\n    // blocks run before we abort the workflow (short-circuit or error path).\n    const runGeneratorReturn = async (): Promise<void> => {\n        if (typeof iterator.return !== 'function') return;\n        // A `yield` inside a `finally` block suspends the generator again\n        // ({done: false}). Resume with next() so the remaining cleanup code\n        // still runs — calling return() again would abort the rest of that\n        // finally block. The pending return completion ends the generator\n        // once all finally blocks have finished.\n        let step = await iterator.return(undefined as unknown as R);\n        while (!step.done) {\n            step = await iterator.next(undefined);\n        }\n    };\n\n    while (true) {\n        let step: IteratorResult<Y, R>;\n        try {\n            step = await iterator.next(input);\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n\n        if (step.done) {\n            try {\n                const awaited = await step.value;\n                if (isResult(awaited)) {\n                    return awaited as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n                }\n                return ok<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>(awaited as OkOfReturn<R>);\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n        }\n\n        const yielded = step.value as unknown;\n        if (!isResult(yielded)) {\n            try {\n                await runGeneratorReturn();\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n            throw new TaskYieldNotResultError(yielded);\n        }\n\n        if (yielded.isOk()) {\n            input = yielded.value;\n            continue;\n        }\n\n        if (yielded.isErr()) {\n            try {\n                await runGeneratorReturn();\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n\n            return yielded as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n        }\n\n        try {\n            await runGeneratorReturn();\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n        throw new InvalidResultStateError('task');\n    }\n}\n\nexport const gen: typeof task = task;\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapOnErrError } from '../errors';\n\n/**\n * Returns the value or throws an Error.\n * Corresponds to Rust `unwrap`.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) throw new UnwrapOnErrError(result.error);\n    throw new InvalidResultStateError('unwrap');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or a default value.\n * Pure function alternative to the instance method.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('unwrapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or calculates a default value using a function.\n * Corresponds to Rust `unwrap_or_else`.\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('unwrapOrElse');\n}\n","import type { Result } from './result';\nimport { unwrapOr } from './unwrapOr';\n\n/**\n * Alias for `unwrapOr`.\n *\n * @deprecated Use {@link unwrapOr} instead. The name is misleading: Rust's\n * `unwrap_or_default` takes no argument (it uses the type's `Default`),\n * whereas this function requires an explicit default value — which is exactly\n * what `unwrapOr` does.\n */\nexport function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T {\n    return unwrapOr(result, defaultValue);\n}\n\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws the original Err value (not wrapped).\n * Useful to preserve `Error` instances including stack traces.\n */\nexport function unwrapOrThrow<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) throw result.error;\n    throw new InvalidResultStateError('unwrapOrThrow');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapErrOnOkError } from '../errors';\n\n/**\n * Returns the error or throws an Error.\n * Corresponds to Rust `unwrap_err`.\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) throw new UnwrapErrOnOkError(result.value);\n    throw new InvalidResultStateError('unwrapErr');\n}\n","import type { Result } from './result';\nimport { ExpectOkError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws an Error with a custom message.\n * Corresponds to Rust `expect`.\n */\nexport function expectResult<T, E>(result: Result<T, E>, message: string): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) {\n        throw new ExpectOkError(message, result.error);\n    }\n    throw new InvalidResultStateError('expectResult');\n}\n","import type { Result } from './result';\nimport { ExpectErrError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the error or throws an Error with a custom message.\n * Corresponds to Rust `expect_err`.\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) {\n        throw new ExpectErrError(message, result.value);\n    }\n    throw new InvalidResultStateError('expectErr');\n}\n","import type { Result, ResultType } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Rebuilds a `Result` from its serialized discriminated form\n * (`{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`), the shape produced\n * by `Result.toSerialized()` and by `JSON.stringify` on a Result.\n *\n * Throws `InvalidResultStateError` for data that is not in that shape.\n */\nexport function fromSerialized<T, E>(data: ResultType<T, E>): Result<T, E> {\n    if (data !== null && typeof data === 'object') {\n        if (data._tag === 'Ok' && 'value' in data) return ok<T, E>(data.value);\n        if (data._tag === 'Err' && 'error' in data) return err<E, T>(data.error);\n    }\n    throw new InvalidResultStateError('fromSerialized');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to a Promise.\n * Ok → resolve(value), Err → reject(error)\n */\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n    if (result.isOk()) {\n        return Promise.resolve(result.value);\n    }\n    if (result.isErr()) return Promise.reject(result.error);\n    throw new InvalidResultStateError('toPromise');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to `T | null`.\n * Ok → value, Err → null\n */\nexport function toNullable<T, E>(result: Result<T, E>): T | null {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return null;\n    throw new InvalidResultStateError('toNullable');\n}\n","import type { Ok, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Ok.\n * Pure function alternative to the instance method.\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T, E> {\n    if (result.isOk()) return true;\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('isOk');\n}\n","import type { Err, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Err.\n * Pure function alternative to the instance method.\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<T, E> {\n    if (result.isErr()) return true;\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('isErr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific value.\n * Corresponds to Rust `contains`.\n *\n * Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and\n * `-0` are distinct, and objects are compared by reference.\n */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n    if (result.isOk()) return Object.is(result.value, value);\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('contains');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific error.\n * Analogous to `contains` for the Err case.\n *\n * Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and\n * `-0` are distinct, and objects are compared by reference.\n */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n    if (result.isErr()) return Object.is(result.error, error);\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('containsErr');\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/gen.ts","../src/core/unwrap.ts","../src/core/unwrapOr.ts","../src/core/unwrapOrElse.ts","../src/core/unwrapOrDefault.ts","../src/core/unwrapOrThrow.ts","../src/core/unwrapErr.ts","../src/core/expectResult.ts","../src/core/expectErr.ts","../src/core/fromSerialized.ts","../src/core/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":["import type { Result } from './core/result';\nimport { err, ok } from './core/result';\nimport { isResult } from './core/isResult';\nimport { InvalidResultStateError, TaskYieldNotResultError } from './errors';\n\ntype AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturn<R> = Awaited<R>;\ntype OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;\ntype ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;\n\n/**\n * What the runner does with a yielded value: resume the generator with the\n * Ok value, or end the workflow with a Result or with a programmer error.\n */\ntype Decision<T, E> =\n    | { readonly kind: 'continue'; readonly input: unknown }\n    | { readonly kind: 'return'; readonly result: Result<T, E> }\n    | { readonly kind: 'throw'; readonly error: unknown };\n\ntype Completion<T, E> = Exclude<Decision<T, E>, { kind: 'continue' }>;\n\n/**\n * Generator-based do-notation for `Result`.\n *\n * Usage:\n * ```ts\n * const out = await task(async function* () {\n *   const user = yield* await fromPromise(findUser(1));\n *   const email = yield* validate(user.email);\n *   return email;\n * });\n * ```\n */\nexport async function task<const Y, const R>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> {\n    type Out = Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n\n    const iterator = makeGenerator();\n\n    const decide = (yielded: unknown): Decision<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown> => {\n        if (!isResult(yielded)) return { kind: 'throw', error: new TaskYieldNotResultError(yielded) };\n        if (yielded.isOk()) return { kind: 'continue', input: yielded.value };\n        if (yielded.isErr()) return { kind: 'return', result: yielded as Out };\n        return { kind: 'throw', error: new InvalidResultStateError('task') };\n    };\n\n    // Resume the suspended generator as if it returned, so its `finally`\n    // blocks run before the workflow ends. Those blocks follow the same\n    // yield protocol as the body: an Ok sends its value back, and an Err or\n    // a non-Result replaces the pending completion and skips the rest of\n    // that block, exactly like a `throw` inside `finally` replaces a pending\n    // exception. Outer `finally` blocks still run.\n    const abandon = async (\n        pending: Completion<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>\n    ): Promise<Completion<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> => {\n        if (typeof iterator.return !== 'function') return pending;\n        let completion = pending;\n        let step = await iterator.return(undefined as unknown as R);\n        while (!step.done) {\n            const decision = decide(step.value);\n            if (decision.kind === 'continue') {\n                step = await iterator.next(decision.input);\n                continue;\n            }\n            completion = decision;\n            step = await iterator.return(undefined as unknown as R);\n        }\n        return completion;\n    };\n\n    let input: unknown = undefined;\n\n    while (true) {\n        let step: IteratorResult<Y, R>;\n        try {\n            step = await iterator.next(input);\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n\n        if (step.done) {\n            try {\n                const awaited = await step.value;\n                if (isResult(awaited)) return awaited as Out;\n                return ok<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>(awaited as OkOfReturn<R>);\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n        }\n\n        const decision = decide(step.value);\n        if (decision.kind === 'continue') {\n            input = decision.input;\n            continue;\n        }\n\n        let completion: Completion<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n        try {\n            completion = await abandon(decision);\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n        if (completion.kind === 'throw') throw completion.error;\n        return completion.result;\n    }\n}\n\nexport const gen: typeof task = task;\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapOnErrError } from '../errors';\n\n/**\n * Returns the value or throws an Error.\n * Corresponds to Rust `unwrap`.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) throw new UnwrapOnErrError(result.error);\n    throw new InvalidResultStateError('unwrap');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or a default value.\n * Pure function alternative to the instance method.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('unwrapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or calculates a default value using a function.\n * Corresponds to Rust `unwrap_or_else`.\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('unwrapOrElse');\n}\n","import type { Result } from './result';\nimport { unwrapOr } from './unwrapOr';\n\n/**\n * Alias for `unwrapOr`.\n *\n * @deprecated Use {@link unwrapOr} instead. The name is misleading: Rust's\n * `unwrap_or_default` takes no argument (it uses the type's `Default`),\n * whereas this function requires an explicit default value — which is exactly\n * what `unwrapOr` does.\n */\nexport function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T {\n    return unwrapOr(result, defaultValue);\n}\n\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws the original Err value (not wrapped).\n * Useful to preserve `Error` instances including stack traces.\n */\nexport function unwrapOrThrow<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) throw result.error;\n    throw new InvalidResultStateError('unwrapOrThrow');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapErrOnOkError } from '../errors';\n\n/**\n * Returns the error or throws an Error.\n * Corresponds to Rust `unwrap_err`.\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) throw new UnwrapErrOnOkError(result.value);\n    throw new InvalidResultStateError('unwrapErr');\n}\n","import type { Result } from './result';\nimport { ExpectOkError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws an Error with a custom message.\n * Corresponds to Rust `expect`.\n */\nexport function expectResult<T, E>(result: Result<T, E>, message: string): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) {\n        throw new ExpectOkError(message, result.error);\n    }\n    throw new InvalidResultStateError('expectResult');\n}\n","import type { Result } from './result';\nimport { ExpectErrError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the error or throws an Error with a custom message.\n * Corresponds to Rust `expect_err`.\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) {\n        throw new ExpectErrError(message, result.value);\n    }\n    throw new InvalidResultStateError('expectErr');\n}\n","import type { Result, ResultType } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Rebuilds a `Result` from its serialized discriminated form\n * (`{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`), the shape produced\n * by `Result.toSerialized()` and by `JSON.stringify` on a Result.\n *\n * Throws `InvalidResultStateError` for data that is not in that shape.\n *\n * @deprecated Rebuild the Result yourself after validating the payload:\n *\n * ```ts\n * const restored = parsed._tag === 'Ok' ? ok(parsed.value) : err(parsed.error);\n * ```\n *\n * `fromSerialized` only checks the envelope, the `_tag` discriminant plus the\n * absence of an own key of the other state, never the payload itself, while its\n * type parameters claim `T` and `E` for whatever `JSON.parse` returned. It\n * also throws for malformed input at exactly the boundary where a Result\n * should be returned. Validate foreign data with your schema tool and\n * then call `ok`/`err`; the shape is exported as `ResultType<T, E>`. This\n * function will be removed in 2.0.\n */\nexport function fromSerialized<T, E>(data: ResultType<T, E>): Result<T, E> {\n    if (data !== null && typeof data === 'object') {\n        // Reading the envelope runs code of the payload: `Object.hasOwn` calls\n        // the `getOwnPropertyDescriptor` trap of a Proxy, and the discriminant\n        // can be a getter. A payload that throws there is not a serialized\n        // Result, and the coded error of this library says so.\n        try {\n            // The key is absent only where `T` or `E` admits `undefined`, see `ResultType`.\n            if (data._tag === 'Ok' && !Object.hasOwn(data, 'error')) return ok<T, E>(data.value as T);\n            if (data._tag === 'Err' && !Object.hasOwn(data, 'value')) return err<E, T>(data.error as E);\n        } catch (error) {\n            const invalid = new InvalidResultStateError('fromSerialized');\n            invalid.cause = error;\n            throw invalid;\n        }\n    }\n    throw new InvalidResultStateError('fromSerialized');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to a Promise.\n * Ok → resolve(value), Err → reject(error)\n */\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n    if (result.isOk()) {\n        return Promise.resolve(result.value);\n    }\n    if (result.isErr()) return Promise.reject(result.error);\n    throw new InvalidResultStateError('toPromise');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to `T | null`.\n * Ok → value, Err → null\n */\nexport function toNullable<T, E>(result: Result<T, E>): T | null {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return null;\n    throw new InvalidResultStateError('toNullable');\n}\n","import type { Ok, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Ok.\n * Pure function alternative to the instance method.\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T, E> {\n    if (result.isOk()) return true;\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('isOk');\n}\n","import type { Err, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Err.\n * Pure function alternative to the instance method.\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<T, E> {\n    if (result.isErr()) return true;\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('isErr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific value.\n * Corresponds to Rust `contains`.\n *\n * Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and\n * `-0` are distinct, and objects are compared by reference.\n */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n    if (result.isOk()) return Object.is(result.value, value);\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('contains');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific error.\n * Analogous to `contains` for the Err case.\n *\n * Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and\n * `-0` are distinct, and objects are compared by reference.\n */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n    if (result.isErr()) return Object.is(result.error, error);\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('containsErr');\n}\n"],"mappings":"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"}

package/dist/operators.cjs

@@ -1,34 +1,415 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_result = require('./result-BBOGxvSH.cjs');
-const require_swap = require('./swap-BnyMBdD_.cjs');
+const require_result = require('./result-DoqQufvR.cjs');
+const require_errors = require('./errors-CVgC7NII.cjs');
 
-exports.and = require_swap.and;
-exports.bimap = require_swap.bimap;
+//#region src/core/map.ts
+/**
+* Transforms the value (Ok case).
+* Corresponds to Rust `map`.
+*/
+function map(project) {
+	return (source) => {
+		if (source.isOk()) return require_result.ok(project(source.value));
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("map");
+	};
+}
+
+//#endregion
+//#region src/core/mapErr.ts
+/**
+* Transforms the error (Err case).
+* Corresponds to Rust `map_err`.
+*/
+function mapErr(project) {
+	return (source) => {
+		if (source.isErr()) return require_result.err(project(source.error));
+		if (source.isOk()) return source;
+		throw new require_errors.InvalidResultStateError("mapErr");
+	};
+}
+
+//#endregion
+//#region src/core/mapBoth.ts
+/**
+* Transforms both the Ok value and the Err error.
+* Corresponds to FP `bimap` / `mapBoth`.
+*/
+function mapBoth(mapOk, mapErr) {
+	return (source) => {
+		if (source.isOk()) return require_result.ok(mapOk(source.value));
+		if (source.isErr()) return require_result.err(mapErr(source.error));
+		throw new require_errors.InvalidResultStateError("mapBoth");
+	};
+}
+/**
+* Alias for `mapBoth`.
+*/
+const bimap = mapBoth;
+
+//#endregion
+//#region src/core/flatMap.ts
+/**
+* Chains another operation that returns a Result.
+* Corresponds to Rust `and_then` or JS `flatMap`.
+*/
+function flatMap(project) {
+	return (source) => {
+		if (source.isOk()) return project(source.value);
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("flatMap");
+	};
+}
+
+//#endregion
+//#region src/core/tap.ts
+/**
+* Executes a side effect (logging, debugging) without changing the Result.
+* Corresponds to Rust `inspect` / `inspect_err`.
+*/
+function tap(observer) {
+	return (source) => {
+		if (source.isOk()) {
+			if (observer.ok) observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) observer.err(source.error);
+			return source;
+		}
+		throw new require_errors.InvalidResultStateError("tap");
+	};
+}
+
+//#endregion
+//#region src/core/filter.ts
+/**
+* Checks a condition. If false, the Result becomes Err.
+* Corresponds to Rust `filter` (partially).
+*/
+function filter(predicate, errorFn) {
+	return (source) => {
+		if (source.isOk()) {
+			if (predicate(source.value)) return source;
+			return require_result.err(errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("filter");
+	};
+}
+
+//#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 require_errors.InvalidResultStateError("fold");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatch.ts
+function tryCatch(fn, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		try {
+			return require_result.ok(fn());
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMap.ts
+function tryMap(project, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new require_errors.InvalidResultStateError("tryMap");
+		try {
+			return require_result.ok(project(source.value));
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#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 require_result.ok(defaultValue);
+		throw new require_errors.InvalidResultStateError("recover");
+	};
+}
+/**
+* Like `recover`, but calculates the default value based on the error.
+*/
+function recoverWith(fn) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return require_result.ok(fn(source.error));
+		throw new require_errors.InvalidResultStateError("recoverWith");
+	};
+}
+
+//#endregion
+//#region src/core/match.ts
+/**
+* Resolves the Result. The end of the pipe.
+* Corresponds to Rust `match`.
+*/
+function match(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("match");
+	};
+}
+
+//#endregion
+//#region src/core/mapAsync.ts
+/**
+* Async version of map.
+*/
+function mapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return require_result.ok(await project(source.value));
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("mapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/mapErrAsync.ts
+/**
+* Async version of mapErr.
+*/
+function mapErrAsync(project) {
+	return async (source) => {
+		if (source.isErr()) return require_result.err(await project(source.error));
+		if (source.isOk()) return source;
+		throw new require_errors.InvalidResultStateError("mapErrAsync");
+	};
+}
+
+//#endregion
+//#region src/core/flatMapAsync.ts
+/**
+* Async version of flatMap.
+*/
+function flatMapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return await project(source.value);
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("flatMapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tapAsync.ts
+/**
+* Async version of tap.
+*/
+function tapAsync(observer) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (observer.ok) await observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) await observer.err(source.error);
+			return source;
+		}
+		throw new require_errors.InvalidResultStateError("tapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/filterAsync.ts
+/**
+* Async version of filter.
+*/
+function filterAsync(predicate, errorFn) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (await predicate(source.value)) return source;
+			return require_result.err(await errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("filterAsync");
+	};
+}
+
+//#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 require_errors.InvalidResultStateError("foldAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatchAsync.ts
+function tryCatchAsync(fn, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		try {
+			return require_result.ok(await fn());
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMapAsync.ts
+function tryMapAsync(project, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new require_errors.InvalidResultStateError("tryMapAsync");
+		try {
+			return require_result.ok(await project(source.value));
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/matchAsync.ts
+/**
+* Async version of match.
+*/
+function matchAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("matchAsync");
+	};
+}
+
+//#endregion
+//#region src/core/and.ts
+/**
+* Combines two Results. Returns the second one only if the first is Ok.
+* Corresponds to Rust `and`.
+*/
+function and(result, other) {
+	if (result.isOk()) return other;
+	if (result.isErr()) return result;
+	throw new require_errors.InvalidResultStateError("and");
+}
+
+//#endregion
+//#region src/core/or.ts
+/**
+* Fallback to another Result if the first is Err.
+* Corresponds to Rust `or`.
+*/
+function or(result, other) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return other;
+	throw new require_errors.InvalidResultStateError("or");
+}
+
+//#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 require_errors.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);
+	if (result.isErr()) return defaultValue;
+	throw new require_errors.InvalidResultStateError("mapOr");
+}
+
+//#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 require_errors.InvalidResultStateError("mapOrElse");
+}
+
+//#endregion
+//#region src/core/swap.ts
+/**
+* Swaps Ok and Err.
+* Result<T, E> → Result<E, T>
+*/
+function swap(result) {
+	if (result.isOk()) return require_result.err(result.value);
+	if (result.isErr()) return require_result.ok(result.error);
+	throw new require_errors.InvalidResultStateError("swap");
+}
+
+//#endregion
+exports.and = and;
+exports.bimap = bimap;
 exports.combine = require_result.combine;
-exports.filter = require_swap.filter;
-exports.filterAsync = require_swap.filterAsync;
-exports.flatMap = require_swap.flatMap;
-exports.flatMapAsync = require_swap.flatMapAsync;
-exports.fold = require_swap.fold;
-exports.foldAsync = require_swap.foldAsync;
-exports.map = require_swap.map;
-exports.mapAsync = require_swap.mapAsync;
-exports.mapBoth = require_swap.mapBoth;
-exports.mapErr = require_swap.mapErr;
-exports.mapErrAsync = require_swap.mapErrAsync;
-exports.mapOr = require_swap.mapOr;
-exports.mapOrElse = require_swap.mapOrElse;
-exports.match = require_swap.match;
-exports.matchAsync = require_swap.matchAsync;
-exports.or = require_swap.or;
-exports.orElse = require_swap.orElse;
-exports.recover = require_swap.recover;
-exports.recoverWith = require_swap.recoverWith;
-exports.swap = require_swap.swap;
-exports.tap = require_swap.tap;
-exports.tapAsync = require_swap.tapAsync;
-exports.tryCatch = require_swap.tryCatch;
-exports.tryCatchAsync = require_swap.tryCatchAsync;
-exports.tryMap = require_swap.tryMap;
-exports.tryMapAsync = require_swap.tryMapAsync;
-exports.zip = require_result.zip;
+exports.filter = filter;
+exports.filterAsync = filterAsync;
+exports.flatMap = flatMap;
+exports.flatMapAsync = flatMapAsync;
+exports.fold = fold;
+exports.foldAsync = foldAsync;
+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.or = or;
+exports.orElse = orElse;
+exports.recover = recover;
+exports.recoverWith = recoverWith;
+exports.swap = swap;
+exports.tap = tap;
+exports.tapAsync = tapAsync;
+exports.tryCatch = tryCatch;
+exports.tryCatchAsync = tryCatchAsync;
+exports.tryMap = tryMap;
+exports.tryMapAsync = tryMapAsync;
+exports.zip = require_result.zip;
+//# sourceMappingURL=operators.cjs.map