@shirudo/result 1.0.1 → 1.1.1

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { A as recover, B as combine, C as flatMapAsync, D as tryMap, E as collectFirstOk, F as flatMap, H as isResult, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, U as matchTag, V as zip, W as Awaitable, _ as tryFn, a as Ok, b as matchAsync, c as ResultType, d as fromPromise, f as fromThrowable, g as tryAsync, h as okIfLazy, i as Err, j as recoverWith, k as swap, l as err, m as okIf, n as sequence, o as OperatorFunction, p as ok, r as AsyncOperatorFunction, s as Result, t as all, u as fromNullable, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-C0jlR3AY.mjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-B8bN6fiI.mjs";
-import { _ as ResultTypeError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapOnErrError, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultErrorCode, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as TaskYieldNotResultError, y as UnwrapErrOnOkError } from "./errors-C5qGMRiU.mjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B5gx9x2E.mjs";
+import { S as Awaitable, _ as tryFn, a as Ok, b as isResult, c as ResultType, d as fromPromise, f as fromThrowable, g as tryAsync, h as okIfLazy, i as Err, l as err, m as okIf, n as sequence, o as OperatorFunction, p as ok, r as AsyncOperatorFunction, s as Result, t as all, u as fromNullable, v as combine, x as matchTag, y as zip } from "./sequence-DDwePRLd.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-C7D6Kttf.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, ResultErrorCode, 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-DT4LdRFV.mjs";
 
 //#region src/gen.d.ts
 type AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;
@@ -11,118 +11,138 @@ type AwaitedReturn<R> = Awaited<R>;
 type OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;
 type ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;
 /**
- * Generator-based do-notation for `Result`.
- *
- * Usage:
- * ```ts
- * const out = await task(async function* () {
- *   const user = yield* await fromPromise(findUser(1));
- *   const email = yield* validate(user.email);
- *   return email;
- * });
- * ```
- */
+* Generator-based do-notation for `Result`.
+*
+* Usage:
+* ```ts
+* const out = await task(async function* () {
+*   const user = yield* await fromPromise(findUser(1));
+*   const email = yield* validate(user.email);
+*   return email;
+* });
+* ```
+*/
 declare function task<const Y, const R>(makeGenerator: () => AnyGenerator<Y, R, unknown>): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;
 declare function task<const Y, const R, EThrown>(makeGenerator: () => AnyGenerator<Y, R, unknown>, onThrow: OnThrow<EThrown>): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;
 declare const gen: typeof task;
 //#endregion
 //#region src/core/unwrap.d.ts
 /**
- * Returns the value or throws an Error.
- * Corresponds to Rust `unwrap`.
- */
+* Returns the value or throws an Error.
+* Corresponds to Rust `unwrap`.
+*/
 declare function unwrap<T, E>(result: Result<T, E>): T;
 //#endregion
 //#region src/core/unwrapOr.d.ts
 /**
- * Returns the value or a default value.
- * Pure function alternative to the instance method.
- */
+* Returns the value or a default value.
+* Pure function alternative to the instance method.
+*/
 declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
 //#endregion
 //#region src/core/unwrapOrElse.d.ts
 /**
- * Returns the value or calculates a default value using a function.
- * Corresponds to Rust `unwrap_or_else`.
- */
+* Returns the value or calculates a default value using a function.
+* Corresponds to Rust `unwrap_or_else`.
+*/
 declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
 //#endregion
 //#region src/core/unwrapOrDefault.d.ts
 /**
- * Alias for `unwrapOr`.
- * Corresponds to Rust `unwrap_or_default` (with explicit default value).
- */
+* Alias for `unwrapOr`.
+*
+* @deprecated Use {@link unwrapOr} instead. The name is misleading: Rust's
+* `unwrap_or_default` takes no argument (it uses the type's `Default`),
+* whereas this function requires an explicit default value — which is exactly
+* what `unwrapOr` does.
+*/
 declare function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T;
 //#endregion
 //#region src/core/unwrapOrThrow.d.ts
 /**
- * Returns the value or throws the original Err value (not wrapped).
- * Useful to preserve `Error` instances including stack traces.
- */
+* Returns the value or throws the original Err value (not wrapped).
+* Useful to preserve `Error` instances including stack traces.
+*/
 declare function unwrapOrThrow<T, E>(result: Result<T, E>): T;
 //#endregion
 //#region src/core/unwrapErr.d.ts
 /**
- * Returns the error or throws an Error.
- * Corresponds to Rust `unwrap_err`.
- */
+* Returns the error or throws an Error.
+* Corresponds to Rust `unwrap_err`.
+*/
 declare function unwrapErr<T, E>(result: Result<T, E>): E;
 //#endregion
 //#region src/core/expectResult.d.ts
 /**
- * Returns the value or throws an Error with a custom message.
- * Corresponds to Rust `expect`.
- */
+* Returns the value or throws an Error with a custom message.
+* Corresponds to Rust `expect`.
+*/
 declare function expectResult<T, E>(result: Result<T, E>, message: string): T;
 //#endregion
 //#region src/core/expectErr.d.ts
 /**
- * Returns the error or throws an Error with a custom message.
- * Corresponds to Rust `expect_err`.
- */
+* Returns the error or throws an Error with a custom message.
+* Corresponds to Rust `expect_err`.
+*/
 declare function expectErr<T, E>(result: Result<T, E>, message: string): E;
 //#endregion
+//#region src/core/fromSerialized.d.ts
+/**
+* Rebuilds a `Result` from its serialized discriminated form
+* (`{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`), the shape produced
+* by `Result.toSerialized()` and by `JSON.stringify` on a Result.
+*
+* Throws `InvalidResultStateError` for data that is not in that shape.
+*/
+declare function fromSerialized<T, E>(data: ResultType<T, E>): Result<T, E>;
+//#endregion
 //#region src/core/toPromise.d.ts
 /**
- * Converts a Result to a Promise.
- * Ok → resolve(value), Err → reject(error)
- */
+* Converts a Result to a Promise.
+* Ok → resolve(value), Err → reject(error)
+*/
 declare function toPromise<T, E>(result: Result<T, E>): Promise<T>;
 //#endregion
 //#region src/core/toNullable.d.ts
 /**
- * Converts a Result to `T | null`.
- * Ok → value, Err → null
- */
+* Converts a Result to `T | null`.
+* Ok → value, Err → null
+*/
 declare function toNullable<T, E>(result: Result<T, E>): T | null;
 //#endregion
 //#region src/core/isOk.d.ts
 /**
- * Checks if a Result is Ok.
- * Pure function alternative to the instance method.
- */
+* Checks if a Result is Ok.
+* Pure function alternative to the instance method.
+*/
 declare function isOk<T, E>(result: Result<T, E>): result is Ok<T, E>;
 //#endregion
 //#region src/core/isErr.d.ts
 /**
- * Checks if a Result is Err.
- * Pure function alternative to the instance method.
- */
+* Checks if a Result is Err.
+* Pure function alternative to the instance method.
+*/
 declare function isErr<T, E>(result: Result<T, E>): result is Err<T, E>;
 //#endregion
 //#region src/core/contains.d.ts
 /**
- * Checks if the Result contains a specific value.
- * Corresponds to Rust `contains`.
- */
+* Checks if the Result contains a specific value.
+* Corresponds to Rust `contains`.
+*
+* Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and
+* `-0` are distinct, and objects are compared by reference.
+*/
 declare function contains<T, E>(result: Result<T, E>, value: T): boolean;
 //#endregion
 //#region src/core/containsErr.d.ts
 /**
- * Checks if the Result contains a specific error.
- * Analogous to `contains` for the Err case.
- */
+* Checks if the Result contains a specific error.
+* Analogous to `contains` for the Err case.
+*
+* Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and
+* `-0` are distinct, and objects are compared by reference.
+*/
 declare function containsErr<T, E>(result: Result<T, E>, error: E): boolean;
 //#endregion
-export { AsyncOperatorFunction, Awaitable, ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, Ok, OperatorFunction, Result, ResultError, ResultErrorCode, ResultType, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, fromThrowable, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, matchTag, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryAsync, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
+export { AsyncOperatorFunction, type Awaitable, 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, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, Ok, OperatorFunction, Result, ResultError, ResultErrorCode, ResultType, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, fromSerialized, fromThrowable, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, matchTag, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryAsync, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","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/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":[],"mappings":";;;;;;KAKK,sDAAsD,UAAU,GAAG,GAAG,KAAK,eAAe,GAAG,GAAG;KAEhG,kBAAkB,UAAU;KAE5B,iCAAiC;KAEjC,mBAAmB,QAAQ;KAC3B,gBAAgB,cAAc,WAAW,2BAA2B,cAAc;AAZ3C,KAavC,WARA,CAAA,CAAA,CAAY,GAQK,aARL,CAQmB,CARnB,CAAA,SAQ8B,MAR9B,CAAA,GAAA,EAAA,KAAA,EAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;;;;;;;;;AAA6E;AAEvD;AAEA;AAGlC,iBAeiB,IAfP,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA,aAAA,EAAA,GAAA,GAgBU,YAhBV,CAgBuB,CAhBvB,EAgB0B,CAhB1B,EAAA,OAAA,CAAA,CAAA,EAiBZ,OAjBY,CAiBJ,MAjBI,CAiBG,UAjBH,CAiBc,CAjBd,CAAA,EAiBkB,YAjBlB,CAiB+B,CAjB/B,CAAA,GAiBoC,WAjBpC,CAiBgD,CAjBhD,CAAA,CAAA,CAAA;AAAoB,iBAkBb,IAlBa,CAAA,OAAA,EAAA,OAAA,EAAA,OAAA,CAAA,CAAA,aAAA,EAAA,GAAA,GAmBV,YAnBU,CAmBG,CAnBH,EAmBM,CAnBN,EAAA,OAAA,CAAA,EAAA,OAAA,EAoBtB,OApBsB,CAoBd,OApBc,CAAA,CAAA,EAqBhC,OArBgC,CAqBxB,MArBwB,CAqBjB,UArBiB,CAqBN,CArBM,CAAA,EAqBF,YArBE,CAqBW,CArBX,CAAA,GAqBgB,WArBhB,CAqB4B,CArB5B,CAAA,GAqBiC,OArBjC,CAAA,CAAA;AAAd,cA8ER,GA9EQ,EAAA,OA8EL,IA9EK;;;;;;;iBCLL,qBAAqB,OAAO,GAAG,KAAK;;;;;;;iBCApC,uBAAuB,OAAO,GAAG,kBAAkB,IAAI;;;;;;;iBCAvD,2BAA2B,OAAO,GAAG,gBAAgB,MAAM,IAAI;;;;;;;iBCA/D,8BAA8B,OAAO,GAAG,kBAAkB,IAAI;;;;;;;iBCA9D,4BAA4B,OAAO,GAAG,KAAK;;;;;;;iBCA3C,wBAAwB,OAAO,GAAG,KAAK;;;;;;;iBCAvC,2BAA2B,OAAO,GAAG,sBAAsB;;;;;;;iBCA3D,wBAAwB,OAAO,GAAG,sBAAsB;;;;;;;iBCAxD,wBAAwB,OAAO,GAAG,KAAK,QAAQ;;;;;;;iBCA/C,yBAAyB,OAAO,GAAG,KAAK;;;;;;;iBCAxC,mBAAmB,OAAO,GAAG,eAAe,GAAG,GAAG;;;;;;;iBCAlD,oBAAoB,OAAO,GAAG,eAAe,IAAI,GAAG;;;;;;;iBCApD,uBAAuB,OAAO,GAAG,WAAW;;;;;;;iBCA5C,0BAA0B,OAAO,GAAG,WAAW"}
+{"version":3,"file":"index.d.mts","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"],"mappings":";;;;;;KAKK,YAAA,0CAAsD,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,CAAA,IAAK,cAAA,CAAe,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA,KAEhG,YAAA,MAAkB,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAEnD,OAAA,OAAc,KAAA,cAAmB,CAAA;AAAA,KAEjC,aAAA,MAAmB,OAAA,CAAQ,CAAA;AAAA,KAC3B,UAAA,MAAgB,aAAA,CAAc,CAAA,UAAW,MAAA,iBAAuB,CAAA,GAAI,aAAA,CAAc,CAAA;AAAA,KAClF,WAAA,MAAiB,aAAA,CAAc,CAAA,UAAW,MAAA,iBAAuB,CAAA;;;;;;;;;;;;;iBAchD,IAAA,mBAClB,aAAA,QAAqB,YAAA,CAAa,CAAA,EAAG,CAAA,aACtC,OAAA,CAAQ,MAAA,CAAO,UAAA,CAAW,CAAA,GAAI,YAAA,CAAa,CAAA,IAAK,WAAA,CAAY,CAAA;AAAA,iBACzC,IAAA,4BAClB,aAAA,QAAqB,YAAA,CAAa,CAAA,EAAG,CAAA,YACrC,OAAA,EAAS,OAAA,CAAQ,OAAA,IAClB,OAAA,CAAQ,MAAA,CAAO,UAAA,CAAW,CAAA,GAAI,YAAA,CAAa,CAAA,IAAK,WAAA,CAAY,CAAA,IAAK,OAAA;AAAA,cAkFvD,GAAA,SAAY,IAAA;;;;;;;iBC5GT,MAAA,OAAa,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA;;;;;;;iBCApC,QAAA,OAAe,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,YAAA,EAAc,CAAA,GAAI,CAAA;;;;;;;iBCAvD,YAAA,OAAmB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,CAAA;;;;;;;;AHPnD;;;iBIWZ,eAAA,OAAsB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,YAAA,EAAc,CAAA,GAAI,CAAA;;;;;;;iBCJ9D,aAAA,OAAoB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA;;;;;;;iBCA3C,SAAA,OAAgB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA;;;;;;;iBCAvC,YAAA,OAAmB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,OAAA,WAAkB,CAAA;;;;;;;iBCA3D,SAAA,OAAgB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,OAAA,WAAkB,CAAA;;;;;;;;ARP5C;;iBSWZ,cAAA,OAAqB,IAAA,EAAM,UAAA,CAAW,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;iBCJxD,SAAA,OAAgB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,CAAA;;;;;;;iBCA/C,UAAA,OAAiB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA;;;;;;;iBCAxC,IAAA,OAAW,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,MAAA,IAAU,EAAA,CAAG,CAAA,EAAG,CAAA;;;;;;;iBCAlD,KAAA,OAAY,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,MAAA,IAAU,GAAA,CAAI,CAAA,EAAG,CAAA;;;;;;;;AbPxC;;iBcUZ,QAAA,OAAe,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,KAAA,EAAO,CAAA;;;;;;;;AdVhC;;iBeUZ,WAAA,OAAkB,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,KAAA,EAAO,CAAA"}

package/dist/index.mjs

@@ -1,12 +1,17 @@
-import { A as flatMap, B as isResult, C as tryCatch, D as match, E as recoverWith, F as combine, I as zip, L as all, M as mapBoth, N as mapErr, O as filter, P as map, R as sequence, S as tryMap, T as recover, _ as tapAsync, a as fromNullable, b as mapAsync, c as ok, d as tryAsync, f as tryFn, g as filterAsync, h as matchAsync, i as err, j as bimap, k as tap, l as okIf, m as tryCatchAsync, n as Ok, o as fromPromise, p as tryMapAsync, r as Result, s as fromThrowable, t as Err, u as okIfLazy, v as flatMapAsync, w as swap, x as collectFirstOk, y as mapErrAsync, z as matchTag } from "./result-DKKaNdOx.mjs";
-import { _ as TaskYieldNotResultError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultTypeError, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as UnwrapErrOnOkError, y as UnwrapOnErrError } from "./errors-2WOswg7r.mjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B0_4r6Jn.mjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-C6Y9hx79.mjs";
+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";
 
 //#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;
+		let step = await iterator.return(void 0);
+		while (!step.done) step = await iterator.next(void 0);
+	};
 	while (true) {
 		let step;
 		try {
@@ -24,20 +29,34 @@ async function task(makeGenerator, onThrow) {
 			return err(onThrow(caught));
 		}
 		const yielded = step.value;
-		if (!isResult(yielded)) throw new TaskYieldNotResultError(yielded);
+		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;
 			continue;
 		}
 		if (yielded.isErr()) {
 			try {
-				if (typeof iterator.return === "function") await iterator.return(void 0);
+				await runGeneratorReturn();
 			} catch (caught) {
 				if (!onThrow) throw caught;
 				return err(onThrow(caught));
 			}
 			return yielded;
 		}
+		try {
+			await runGeneratorReturn();
+		} catch (caught) {
+			if (!onThrow) throw caught;
+			return err(onThrow(caught));
+		}
 		throw new InvalidResultStateError("task");
 	}
 }
@@ -83,7 +102,11 @@ function unwrapOrElse(result, fn) {
 //#region src/core/unwrapOrDefault.ts
 /**
 * Alias for `unwrapOr`.
-* Corresponds to Rust `unwrap_or_default` (with explicit default value).
+*
+* @deprecated Use {@link unwrapOr} instead. The name is misleading: Rust's
+* `unwrap_or_default` takes no argument (it uses the type's `Default`),
+* whereas this function requires an explicit default value — which is exactly
+* what `unwrapOr` does.
 */
 function unwrapOrDefault(result, defaultValue) {
 	return unwrapOr(result, defaultValue);
@@ -121,7 +144,7 @@ function unwrapErr(result) {
 */
 function expectResult(result, message) {
 	if (result.isOk()) return result.value;
-	if (result.isErr()) throw new ExpectOkError(message);
+	if (result.isErr()) throw new ExpectOkError(message, result.error);
 	throw new InvalidResultStateError("expectResult");
 }
 
@@ -133,10 +156,27 @@ function expectResult(result, message) {
 */
 function expectErr(result, message) {
 	if (result.isErr()) return result.error;
-	if (result.isOk()) throw new ExpectErrError(message);
+	if (result.isOk()) throw new ExpectErrError(message, result.value);
 	throw new InvalidResultStateError("expectErr");
 }
 
+//#endregion
+//#region src/core/fromSerialized.ts
+/**
+* Rebuilds a `Result` from its serialized discriminated form
+* (`{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`), the shape produced
+* by `Result.toSerialized()` and by `JSON.stringify` on a Result.
+*
+* Throws `InvalidResultStateError` for data that is not in that shape.
+*/
+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);
+	}
+	throw new InvalidResultStateError("fromSerialized");
+}
+
 //#endregion
 //#region src/core/toPromise.ts
 /**
@@ -190,9 +230,12 @@ function isErr(result) {
 /**
 * Checks if the Result contains a specific value.
 * Corresponds to Rust `contains`.
+*
+* Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and
+* `-0` are distinct, and objects are compared by reference.
 */
 function contains(result, value) {
-	if (result.isOk()) return result.value === value;
+	if (result.isOk()) return Object.is(result.value, value);
 	if (result.isErr()) return false;
 	throw new InvalidResultStateError("contains");
 }
@@ -202,13 +245,16 @@ function contains(result, value) {
 /**
 * Checks if the Result contains a specific error.
 * Analogous to `contains` for the Err case.
+*
+* Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and
+* `-0` are distinct, and objects are compared by reference.
 */
 function containsErr(result, error) {
-	if (result.isErr()) return result.error === error;
+	if (result.isErr()) return Object.is(result.error, error);
 	if (result.isOk()) return false;
 	throw new InvalidResultStateError("containsErr");
 }
 
 //#endregion
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, Ok, Result, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, fromThrowable, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, matchTag, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryAsync, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, Ok, Result, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, fromSerialized, fromThrowable, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, matchTag, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryAsync, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["input: unknown","step: IteratorResult<Y, R>"],"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/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    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            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                if (typeof iterator.return === 'function') {\n                    await iterator.return(undefined as unknown as R);\n                }\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        throw new InvalidResultStateError('task');\n    }\n}\n\nexport const gen = 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 * Corresponds to Rust `unwrap_or_default` (with explicit default value).\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);\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);\n    }\n    throw new InvalidResultStateError('expectErr');\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 */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n    if (result.isOk()) return 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 */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n    if (result.isErr()) return 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 * 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":";;;;;;AAkCA,eAAsB,KAClB,eACA,SAC0E;CAC1E,MAAM,WAAW,cAAc;CAC/B,IAAI,QAAiB;CAIrB,MAAM,qBAAqB,YAA2B;EAClD,IAAI,OAAO,SAAS,WAAW,YAAY;EAM3C,IAAI,OAAO,MAAM,SAAS,OAAO,MAAyB;EAC1D,OAAO,CAAC,KAAK,MACT,OAAO,MAAM,SAAS,KAAK,MAAS;CAE5C;CAEA,OAAO,MAAM;EACT,IAAI;EACJ,IAAI;GACA,OAAO,MAAM,SAAS,KAAK,KAAK;EACpC,SAAS,QAAQ;GACb,IAAI,CAAC,SAAS,MAAM;GACpB,OAAO,IAA+D,QAAQ,MAAM,CAAC;EACzF;EAEA,IAAI,KAAK,MACL,IAAI;GACA,MAAM,UAAU,MAAM,KAAK;GAC3B,IAAI,SAAS,OAAO,GAChB,OAAO;GAEX,OAAO,GAA8D,OAAwB;EACjG,SAAS,QAAQ;GACb,IAAI,CAAC,SAAS,MAAM;GACpB,OAAO,IAA+D,QAAQ,MAAM,CAAC;EACzF;EAGJ,MAAM,UAAU,KAAK;EACrB,IAAI,CAAC,SAAS,OAAO,GAAG;GACpB,IAAI;IACA,MAAM,mBAAmB;GAC7B,SAAS,QAAQ;IACb,IAAI,CAAC,SAAS,MAAM;IACpB,OAAO,IAA+D,QAAQ,MAAM,CAAC;GACzF;GACA,MAAM,IAAI,wBAAwB,OAAO;EAC7C;EAEA,IAAI,QAAQ,KAAK,GAAG;GAChB,QAAQ,QAAQ;GAChB;EACJ;EAEA,IAAI,QAAQ,MAAM,GAAG;GACjB,IAAI;IACA,MAAM,mBAAmB;GAC7B,SAAS,QAAQ;IACb,IAAI,CAAC,SAAS,MAAM;IACpB,OAAO,IAA+D,QAAQ,MAAM,CAAC;GACzF;GAEA,OAAO;EACX;EAEA,IAAI;GACA,MAAM,mBAAmB;EAC7B,SAAS,QAAQ;GACb,IAAI,CAAC,SAAS,MAAM;GACpB,OAAO,IAA+D,QAAQ,MAAM,CAAC;EACzF;EACA,MAAM,IAAI,wBAAwB,MAAM;CAC5C;AACJ;AAEA,MAAa,MAAmB;;;;;;;;AC5GhC,SAAgB,OAAa,QAAyB;CAClD,IAAI,OAAO,KAAK,GACZ,OAAO,OAAO;CAElB,IAAI,OAAO,MAAM,GAAG,MAAM,IAAI,iBAAiB,OAAO,KAAK;CAC3D,MAAM,IAAI,wBAAwB,QAAQ;AAC9C;;;;;;;;ACNA,SAAgB,SAAe,QAAsB,cAAoB;CACrE,IAAI,OAAO,KAAK,GAAG,OAAO,OAAO;CACjC,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAI,wBAAwB,UAAU;AAChD;;;;;;;;ACJA,SAAgB,aAAmB,QAAsB,IAAwB;CAC7E,IAAI,OAAO,KAAK,GAAG,OAAO,OAAO;CACjC,IAAI,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,KAAK;CAC1C,MAAM,IAAI,wBAAwB,cAAc;AACpD;;;;;;;;;;;;ACAA,SAAgB,gBAAsB,QAAsB,cAAoB;CAC5E,OAAO,SAAS,QAAQ,YAAY;AACxC;;;;;;;;ACNA,SAAgB,cAAoB,QAAyB;CACzD,IAAI,OAAO,KAAK,GAAG,OAAO,OAAO;CACjC,IAAI,OAAO,MAAM,GAAG,MAAM,OAAO;CACjC,MAAM,IAAI,wBAAwB,eAAe;AACrD;;;;;;;;ACJA,SAAgB,UAAgB,QAAyB;CACrD,IAAI,OAAO,MAAM,GACb,OAAO,OAAO;CAElB,IAAI,OAAO,KAAK,GAAG,MAAM,IAAI,mBAAmB,OAAO,KAAK;CAC5D,MAAM,IAAI,wBAAwB,WAAW;AACjD;;;;;;;;ACNA,SAAgB,aAAmB,QAAsB,SAAoB;CACzE,IAAI,OAAO,KAAK,GACZ,OAAO,OAAO;CAElB,IAAI,OAAO,MAAM,GACb,MAAM,IAAI,cAAc,SAAS,OAAO,KAAK;CAEjD,MAAM,IAAI,wBAAwB,cAAc;AACpD;;;;;;;;ACRA,SAAgB,UAAgB,QAAsB,SAAoB;CACtE,IAAI,OAAO,MAAM,GACb,OAAO,OAAO;CAElB,IAAI,OAAO,KAAK,GACZ,MAAM,IAAI,eAAe,SAAS,OAAO,KAAK;CAElD,MAAM,IAAI,wBAAwB,WAAW;AACjD;;;;;;;;;;;ACJA,SAAgB,eAAqB,MAAsC;CACvE,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;EAC3C,IAAI,KAAK,SAAS,QAAQ,WAAW,MAAM,OAAO,GAAS,KAAK,KAAK;EACrE,IAAI,KAAK,SAAS,SAAS,WAAW,MAAM,OAAO,IAAU,KAAK,KAAK;CAC3E;CACA,MAAM,IAAI,wBAAwB,gBAAgB;AACtD;;;;;;;;ACVA,SAAgB,UAAgB,QAAkC;CAC9D,IAAI,OAAO,KAAK,GACZ,OAAO,QAAQ,QAAQ,OAAO,KAAK;CAEvC,IAAI,OAAO,MAAM,GAAG,OAAO,QAAQ,OAAO,OAAO,KAAK;CACtD,MAAM,IAAI,wBAAwB,WAAW;AACjD;;;;;;;;ACNA,SAAgB,WAAiB,QAAgC;CAC7D,IAAI,OAAO,KAAK,GAAG,OAAO,OAAO;CACjC,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAI,wBAAwB,YAAY;AAClD;;;;;;;;ACJA,SAAgB,KAAW,QAA0C;CACjE,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAI,wBAAwB,MAAM;AAC5C;;;;;;;;ACJA,SAAgB,MAAY,QAA2C;CACnE,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,MAAM,IAAI,wBAAwB,OAAO;AAC7C;;;;;;;;;;;ACDA,SAAgB,SAAe,QAAsB,OAAmB;CACpE,IAAI,OAAO,KAAK,GAAG,OAAO,OAAO,GAAG,OAAO,OAAO,KAAK;CACvD,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAI,wBAAwB,UAAU;AAChD;;;;;;;;;;;ACJA,SAAgB,YAAkB,QAAsB,OAAmB;CACvE,IAAI,OAAO,MAAM,GAAG,OAAO,OAAO,GAAG,OAAO,OAAO,KAAK;CACxD,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,MAAM,IAAI,wBAAwB,aAAa;AACnD"}

package/dist/operators.cjs

@@ -1,33 +1,34 @@
-const require_result = require('./result-CY-KIivk.cjs');
-const require_mapOrElse = require('./mapOrElse-H-GvAUka.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_result = require('./result-BBOGxvSH.cjs');
+const require_swap = require('./swap-BnyMBdD_.cjs');
 
-exports.and = require_mapOrElse.and;
-exports.bimap = require_result.bimap;
+exports.and = require_swap.and;
+exports.bimap = require_swap.bimap;
 exports.combine = require_result.combine;
-exports.filter = require_result.filter;
-exports.filterAsync = require_result.filterAsync;
-exports.flatMap = require_result.flatMap;
-exports.flatMapAsync = require_result.flatMapAsync;
-exports.fold = require_mapOrElse.fold;
-exports.foldAsync = require_mapOrElse.foldAsync;
-exports.map = require_result.map;
-exports.mapAsync = require_result.mapAsync;
-exports.mapBoth = require_result.mapBoth;
-exports.mapErr = require_result.mapErr;
-exports.mapErrAsync = require_result.mapErrAsync;
-exports.mapOr = require_mapOrElse.mapOr;
-exports.mapOrElse = require_mapOrElse.mapOrElse;
-exports.match = require_result.match;
-exports.matchAsync = require_result.matchAsync;
-exports.or = require_mapOrElse.or;
-exports.orElse = require_mapOrElse.orElse;
-exports.recover = require_result.recover;
-exports.recoverWith = require_result.recoverWith;
-exports.swap = require_result.swap;
-exports.tap = require_result.tap;
-exports.tapAsync = require_result.tapAsync;
-exports.tryCatch = require_result.tryCatch;
-exports.tryCatchAsync = require_result.tryCatchAsync;
-exports.tryMap = require_result.tryMap;
-exports.tryMapAsync = require_result.tryMapAsync;
+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;

package/dist/operators.d.cts

@@ -1,3 +1,3 @@
-import { A as recover, B as combine, C as flatMapAsync, D as tryMap, F as flatMap, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, V as zip, b as matchAsync, j as recoverWith, k as swap, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-Br6tAIIu.cjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-DIe7LkYV.cjs";
+import { v as combine, y as zip } from "./sequence-DDwePRLd.cjs";
+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-CrHQZIax.cjs";
 export { and, bimap, combine, 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, zip };

package/dist/operators.d.mts

@@ -1,3 +1,3 @@
-import { A as recover, B as combine, C as flatMapAsync, D as tryMap, F as flatMap, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, V as zip, b as matchAsync, j as recoverWith, k as swap, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-C0jlR3AY.mjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B5gx9x2E.mjs";
+import { v as combine, y as zip } from "./sequence-DDwePRLd.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-DT4LdRFV.mjs";
 export { and, bimap, combine, 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, zip };

package/dist/operators.mjs

@@ -1,4 +1,4 @@
-import { A as flatMap, C as tryCatch, D as match, E as recoverWith, F as combine, I as zip, M as mapBoth, N as mapErr, O as filter, P as map, S as tryMap, T as recover, _ as tapAsync, b as mapAsync, g as filterAsync, h as matchAsync, j as bimap, k as tap, m as tryCatchAsync, p as tryMapAsync, v as flatMapAsync, w as swap, y as mapErrAsync } from "./result-DKKaNdOx.mjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B0_4r6Jn.mjs";
+import { m as zip, p as combine } from "./result-q9Na2bGa.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";
 
 export { and, bimap, combine, 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, zip };