@shirudo/result 1.0.1 → 1.1.0

package/dist/flatten-C7D6Kttf.d.mts

@@ -0,0 +1,81 @@
+import { S as Awaitable, s as Result } from "./sequence-DDwePRLd.mjs";
+
+//#region src/core/sequenceRecord.d.ts
+type OkValueOf$3<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$3<R> = R extends Result<any, infer E> ? E : never;
+/**
+* Like `sequence`, but for Records/Objects.
+* Short-circuits on the first Err.
+*/
+declare function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any> }>(record: R): Result<{ [K in keyof R]: OkValueOf$3<R[K]> }, ErrValueOf$3<R[keyof R]>>;
+//#endregion
+//#region src/core/collectFirstOk.d.ts
+type OkValueOf$2<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$2<R> = R extends Result<any, infer E> ? E : never;
+/**
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
+*/
+declare function collectFirstOk<const Results extends readonly Result<any, any>[]>(results: Results): Result<OkValueOf$2<Results[number]>, ErrValueOf$2<Results[number]>[]>;
+//#endregion
+//#region src/core/collectFirstOkAsync.d.ts
+type CollectFirstOkAsyncInput$1 = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput$1<I> = ResolvedResult$1<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput$1<I> = ResolvedResult$1<I> extends Result<any, infer E> ? E : never;
+/**
+* Async version of collectFirstOk.
+*
+* - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+* - Processes inputs strictly sequentially (like `for ... of` + `await`).
+* - Returns the first `Ok` and collects all errors if no `Ok` is found.
+*/
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, ErrValueOfInput$1<Inputs[number]>[]>>;
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.d.ts
+type CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;
+/**
+* Parallel version of `collectFirstOkAsync`.
+*
+* - Starts all inputs immediately (Promises or Thunks).
+* - Returns the first `Ok` as soon as it is available.
+* - If no `Ok` is found, returns an `Err` with all error values (in input order).
+* - Rejections are treated as `ErrValue` (`caught as ErrValue`).
+* - If multiple inputs provide an `Ok`, the one that completes first wins.
+*   In case of simultaneous completion, the first observed result wins.
+* - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
+*/
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
+//#endregion
+//#region src/core/collectAllErrors.d.ts
+type OkValueOf$1<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$1<R> = R extends Result<any, infer E> ? E : never;
+type CollectionValues<Results extends readonly Result<any, any>[]> = { -readonly [K in keyof Results]: OkValueOf$1<Results[K]> };
+/**
+* Combines a list of Results.
+* Return Ok(values) only if all are Ok, otherwise Err([errors]).
+*/
+declare function collectAllErrors<const Results extends readonly Result<any, any>[]>(results: Results): Result<CollectionValues<Results>, Array<ErrValueOf$1<Results[number]>>>;
+//#endregion
+//#region src/core/partition.d.ts
+type OkValueOf<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf<R> = R extends Result<any, infer E> ? E : never;
+/**
+* Partitions Results into Ok values and Err errors.
+*/
+declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
+//#endregion
+//#region src/core/flatten.d.ts
+/**
+* Flattens a nested Result.
+* Result<Result<T, E>, E> → Result<T, E>
+* Corresponds to Rust `flatten`.
+*/
+declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
+//#endregion
+export { collectFirstOkAsync as a, collectFirstOkParallelAsync as i, partition as n, collectFirstOk as o, collectAllErrors as r, sequenceRecord as s, flatten as t };
+//# sourceMappingURL=flatten-C7D6Kttf.d.mts.map

package/dist/flatten-C7D6Kttf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-C7D6Kttf.d.mts","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"mappings":";;;KAKK,WAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,YAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAN1B;;;;AAAA,iBAYZ,cAAA,wCAAsD,CAAA,GAAI,MAAA,cACtE,MAAA,EAAQ,CAAA,GACT,MAAA,eAAqB,CAAA,GAAI,WAAA,CAAU,CAAA,CAAE,CAAA,MAAO,YAAA,CAAW,CAAA,OAAQ,CAAA;;;KCV7D,WAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,YAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;ADL1B;;;;;AAAA,iBCYZ,cAAA,gCAA8C,MAAA,cAC1D,OAAA,EAAS,OAAA,GACV,MAAA,CAAO,WAAA,CAAU,OAAA,WAAkB,YAAA,CAAW,OAAA;;;KCT5C,0BAAA,GACC,OAAA,CAAQ,MAAA,qBACD,SAAA,CAAU,MAAA;AAAA,KAElB,gBAAA,MAAoB,CAAA,2BAA0B,OAAA,CAAQ,CAAA,IAAK,CAAA,SAAU,OAAA,YAAmB,CAAA;AAAA,KACxF,gBAAA,MAAoB,gBAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;AAAA,KACrE,iBAAA,MAAqB,gBAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;;;;;;;;iBASrD,mBAAA,+BAAkD,0BAAA,IACpE,MAAA,EAAQ,MAAA,GACT,OAAA,CAAQ,MAAA,CAAO,gBAAA,CAAe,MAAA,WAAiB,iBAAA,CAAgB,MAAA;;;KCjB7D,wBAAA,GAA2B,OAAA,CAAQ,MAAA,qBAA2B,SAAA,CAAU,MAAA;AAAA,KAExE,cAAA,MAAoB,CAAA,2BAA0B,OAAA,CAAQ,CAAA,IAAK,CAAA,SAAU,OAAA,YAAmB,CAAA;AAAA,KACxF,cAAA,MAAoB,cAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;AAAA,KACrE,eAAA,MAAqB,cAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;;;;;;;;AHJtB;AAAA;;;iBGiB/B,2BAAA,+BAA0D,wBAAA,IAC5E,MAAA,EAAQ,MAAA,GACT,OAAA,CAAQ,MAAA,CAAO,cAAA,CAAe,MAAA,WAAiB,eAAA,CAAgB,MAAA;;;KCpB7D,WAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,YAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KACjD,gBAAA,0BAA0C,MAAA,wCACrB,OAAA,GAAU,WAAA,CAAU,OAAA,CAAQ,CAAA;;;;;iBAOtC,gBAAA,gCAAgD,MAAA,cAC5D,OAAA,EAAS,OAAA,GACV,MAAA,CAAO,gBAAA,CAAiB,OAAA,GAAU,KAAA,CAAM,YAAA,CAAW,OAAA;;;KCbjD,SAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,UAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;ALJ1B;;;AAAA,iBKSZ,SAAA,gCAAyC,MAAA,cACrD,OAAA,EAAS,OAAA,IACT,GAAA,EAAK,KAAA,CAAM,SAAA,CAAU,OAAA,YAAmB,IAAA,EAAM,KAAA,CAAM,UAAA,CAAW,OAAA;;;;;ALXvC;;;iBMQZ,OAAA,OAAc,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA"}

package/dist/{flatten-C6Y9hx79.mjs → flatten-ChTL5BfA.mjs}

@@ -1,5 +1,5 @@
-import { B as isResult, c as ok, i as err } from "./result-DKKaNdOx.mjs";
-import { f as InvalidResultStateError } from "./errors-2WOswg7r.mjs";
+import { c as ok, i as err, v as isResult } from "./result-q9Na2bGa.mjs";
+import { InvalidResultStateError } from "./errors.mjs";
 
 //#region src/core/sequenceRecord.ts
 /**
@@ -21,6 +21,26 @@ function sequenceRecord(record) {
 	return ok(out);
 }
 
+//#endregion
+//#region src/core/collectFirstOk.ts
+/**
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
+*/
+function collectFirstOk(results) {
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) return ok(result.value);
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("collectFirstOk");
+	}
+	return err(errors);
+}
+
 //#endregion
 //#region src/core/collectFirstOkAsync.ts
 /**
@@ -143,5 +163,5 @@ function flatten(result) {
 }
 
 //#endregion
-export { collectFirstOkAsync as a, collectFirstOkParallelAsync as i, partition as n, sequenceRecord as o, collectAllErrors as r, flatten as t };
-//# sourceMappingURL=flatten-C6Y9hx79.mjs.map
+export { collectFirstOkAsync as a, collectFirstOkParallelAsync as i, partition as n, collectFirstOk as o, collectAllErrors as r, sequenceRecord as s, flatten as t };
+//# sourceMappingURL=flatten-ChTL5BfA.mjs.map

package/dist/flatten-ChTL5BfA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-ChTL5BfA.mjs","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"sourcesContent":["import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\nimport { isResult } from './isResult';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Like `sequence`, but for Records/Objects.\n * Short-circuits on the first Err.\n */\nexport function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any> }>(\n    record: R\n): Result<{ [K in keyof R]: OkValueOf<R[K]> }, ErrValueOf<R[keyof R]>> {\n    type Out = { [K in keyof R]: OkValueOf<R[K]> };\n    type E = ErrValueOf<R[keyof R]>;\n\n    const out: Partial<Out> = {};\n\n    for (const key of Reflect.ownKeys(record) as Array<keyof R>) {\n        const result = record[key];\n        if (!isResult(result)) throw new InvalidResultStateError('sequenceRecord');\n        if (result.isOk()) {\n            out[key] = result.value as Out[typeof key];\n            continue;\n        }\n        if (result.isErr()) return result as unknown as Result<Out, E>;\n        throw new InvalidResultStateError('sequenceRecord');\n    }\n\n    return ok<Out, E>(out as Out);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Parse a set of `Result`s, short-circuits when an input value is `Ok`.\n * If no `Ok` is found, returns an `Err` containing the collected error values.\n * Useful for \"try multiple approaches until one works\" patterns.\n */\nexport function collectFirstOk<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]> {\n    const errors: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            return ok<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]>(\n                result.value as OkValueOf<Results[number]>\n            );\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectFirstOk');\n    }\n\n    return err<ErrValueOf<Results[number]>[], OkValueOf<Results[number]>>(errors);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport type { Awaitable } from './pipeable';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput =\n    | Promise<Result<any, any>>\n    | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Async version of collectFirstOk.\n *\n * - Takes either already started Promises or \"Thunks\" (`() => Awaitable<Result<...>>`).\n * - Processes inputs strictly sequentially (like `for ... of` + `await`).\n * - Returns the first `Ok` and collects all errors if no `Ok` is found.\n */\nexport async function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n    const errors: Array<ErrValueOfInput<Inputs[number]>> = [];\n\n    for (const input of inputs) {\n        const pendingResult = typeof input === 'function' ? input() : input;\n        let result: Result<any, any>;\n        try {\n            result = await pendingResult;\n        } catch (error) {\n            errors.push(error as ErrValueOfInput<Inputs[number]>);\n            continue;\n        }\n\n        if (result.isOk()) {\n            return ok<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>(\n                result.value as OkValueOfInput<Inputs[number]>\n            );\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOfInput<Inputs[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectFirstOkAsync');\n    }\n\n    return err<ErrValueOfInput<Inputs[number]>[], OkValueOfInput<Inputs[number]>>(errors);\n}\n","import type { Awaitable } from './pipeable';\nimport type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Parallel version of `collectFirstOkAsync`.\n *\n * - Starts all inputs immediately (Promises or Thunks).\n * - Returns the first `Ok` as soon as it is available.\n * - If no `Ok` is found, returns an `Err` with all error values (in input order).\n * - Rejections are treated as `ErrValue` (`caught as ErrValue`).\n * - If multiple inputs provide an `Ok`, the one that completes first wins.\n *   In case of simultaneous completion, the first observed result wins.\n * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.\n */\nexport async function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n    type OkValue = OkValueOfInput<Inputs[number]>;\n    type ErrValue = ErrValueOfInput<Inputs[number]>;\n\n    if (inputs.length === 0) {\n        return err<ErrValue[], OkValue>([]);\n    }\n\n    const started = inputs.map((input) =>\n        typeof input === 'function' ? Promise.resolve().then(input) : input\n    );\n\n    const firstOk = new Promise<Result<OkValue, ErrValue[]>>((resolve) => {\n        for (const promise of started) {\n            promise\n                .then((result) => {\n                    if (result.isOk()) {\n                        resolve(ok<OkValue, ErrValue[]>(result.value as OkValue));\n                    }\n                })\n                .catch(() => {\n                    // Ignored here; handled in allSettled below.\n                });\n        }\n    });\n\n    const allErrors = Promise.allSettled(started).then((settled) => {\n        const errors: ErrValue[] = [];\n        for (const entry of settled) {\n            if (entry.status === 'fulfilled') {\n                const result = entry.value;\n                if (result.isErr()) {\n                    errors.push(result.error as ErrValue);\n                } else if (!result.isOk()) {\n                    throw new InvalidResultStateError('collectFirstOkParallelAsync');\n                }\n            } else {\n                errors.push(entry.reason as ErrValue);\n            }\n        }\n        return err<ErrValue[], OkValue>(errors);\n    });\n\n    return Promise.race([firstOk, allErrors]);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\ntype CollectionValues<Results extends readonly Result<any, any>[]> = {\n    -readonly [K in keyof Results]: OkValueOf<Results[K]>;\n};\n\n/**\n * Combines a list of Results.\n * Return Ok(values) only if all are Ok, otherwise Err([errors]).\n */\nexport function collectAllErrors<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<CollectionValues<Results>, Array<ErrValueOf<Results[number]>>> {\n    const values: Array<OkValueOf<Results[number]>> = [];\n    const errors: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            values.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectAllErrors');\n    }\n\n    return errors.length === 0\n        ? ok<CollectionValues<Results>, Array<ErrValueOf<Results[number]>>>(values as CollectionValues<Results>)\n        : err<Array<ErrValueOf<Results[number]>>, CollectionValues<Results>>(errors);\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Partitions Results into Ok values and Err errors.\n */\nexport function partition<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>] {\n    const oks: Array<OkValueOf<Results[number]>> = [];\n    const errs: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            oks.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) {\n            errs.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('partition');\n    }\n\n    return [oks, errs];\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Flattens a nested Result.\n * Result<Result<T, E>, E> → Result<T, E>\n * Corresponds to Rust `flatten`.\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) return result as unknown as Result<T, E>;\n    throw new InvalidResultStateError('flatten');\n}\n"],"mappings":";;;;;;;;AAYA,SAAgB,eACZ,QACmE;CAInE,MAAM,MAAoB,CAAC;CAE3B,KAAK,MAAM,OAAO,QAAQ,QAAQ,MAAM,GAAqB;EACzD,MAAM,SAAS,OAAO;EACtB,IAAI,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,wBAAwB,gBAAgB;EACzE,IAAI,OAAO,KAAK,GAAG;GACf,IAAI,OAAO,OAAO;GAClB;EACJ;EACA,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAI,wBAAwB,gBAAgB;CACtD;CAEA,OAAO,GAAW,GAAU;AAChC;;;;;;;;;ACpBA,SAAgB,eACZ,SACiE;CACjE,MAAM,SAA6C,CAAC;CAEpD,KAAK,MAAM,UAAU,SAAS;EAC1B,IAAI,OAAO,KAAK,GACZ,OAAO,GACH,OAAO,KACX;EAEJ,IAAI,OAAO,MAAM,GAAG;GAChB,OAAO,KAAK,OAAO,KAAoC;GACvD;EACJ;EACA,MAAM,IAAI,wBAAwB,gBAAgB;CACtD;CAEA,OAAO,IAA+D,MAAM;AAChF;;;;;;;;;;;ACXA,eAAsB,oBAClB,QACkF;CAClF,MAAM,SAAiD,CAAC;CAExD,KAAK,MAAM,SAAS,QAAQ;EACxB,MAAM,gBAAgB,OAAO,UAAU,aAAa,MAAM,IAAI;EAC9D,IAAI;EACJ,IAAI;GACA,SAAS,MAAM;EACnB,SAAS,OAAO;GACZ,OAAO,KAAK,KAAwC;GACpD;EACJ;EAEA,IAAI,OAAO,KAAK,GACZ,OAAO,GACH,OAAO,KACX;EAEJ,IAAI,OAAO,MAAM,GAAG;GAChB,OAAO,KAAK,OAAO,KAAwC;GAC3D;EACJ;EACA,MAAM,IAAI,wBAAwB,qBAAqB;CAC3D;CAEA,OAAO,IAAuE,MAAM;AACxF;;;;;;;;;;;;;;;AC1BA,eAAsB,4BAClB,QACkF;CAIlF,IAAI,OAAO,WAAW,GAClB,OAAO,IAAyB,CAAC,CAAC;CAGtC,MAAM,UAAU,OAAO,KAAK,UACxB,OAAO,UAAU,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,KAAK,IAAI,KAClE;CAEA,MAAM,UAAU,IAAI,SAAsC,YAAY;EAClE,KAAK,MAAM,WAAW,SAClB,QACK,MAAM,WAAW;GACd,IAAI,OAAO,KAAK,GACZ,QAAQ,GAAwB,OAAO,KAAgB,CAAC;EAEhE,CAAC,CAAC,CACD,YAAY,CAEb,CAAC;CAEb,CAAC;CAED,MAAM,YAAY,QAAQ,WAAW,OAAO,CAAC,CAAC,MAAM,YAAY;EAC5D,MAAM,SAAqB,CAAC;EAC5B,KAAK,MAAM,SAAS,SAChB,IAAI,MAAM,WAAW,aAAa;GAC9B,MAAM,SAAS,MAAM;GACrB,IAAI,OAAO,MAAM,GACb,OAAO,KAAK,OAAO,KAAiB;QACjC,IAAI,CAAC,OAAO,KAAK,GACpB,MAAM,IAAI,wBAAwB,6BAA6B;EAEvE,OACI,OAAO,KAAK,MAAM,MAAkB;EAG5C,OAAO,IAAyB,MAAM;CAC1C,CAAC;CAED,OAAO,QAAQ,KAAK,CAAC,SAAS,SAAS,CAAC;AAC5C;;;;;;;;ACtDA,SAAgB,iBACZ,SACqE;CACrE,MAAM,SAA4C,CAAC;CACnD,MAAM,SAA6C,CAAC;CAEpD,KAAK,MAAM,UAAU,SAAS;EAC1B,IAAI,OAAO,KAAK,GAAG;GACf,OAAO,KAAK,OAAO,KAAmC;GACtD;EACJ;EACA,IAAI,OAAO,MAAM,GAAG;GAChB,OAAO,KAAK,OAAO,KAAoC;GACvD;EACJ;EACA,MAAM,IAAI,wBAAwB,kBAAkB;CACxD;CAEA,OAAO,OAAO,WAAW,IACnB,GAAkE,MAAmC,IACrG,IAAmE,MAAM;AACnF;;;;;;;AC1BA,SAAgB,UACZ,SACkF;CAClF,MAAM,MAAyC,CAAC;CAChD,MAAM,OAA2C,CAAC;CAElD,KAAK,MAAM,UAAU,SAAS;EAC1B,IAAI,OAAO,KAAK,GAAG;GACf,IAAI,KAAK,OAAO,KAAmC;GACnD;EACJ;EACA,IAAI,OAAO,MAAM,GAAG;GAChB,KAAK,KAAK,OAAO,KAAoC;GACrD;EACJ;EACA,MAAM,IAAI,wBAAwB,WAAW;CACjD;CAEA,OAAO,CAAC,KAAK,IAAI;AACrB;;;;;;;;;ACpBA,SAAgB,QAAc,QAA+C;CACzE,IAAI,OAAO,KAAK,GACZ,OAAO,OAAO;CAElB,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAI,wBAAwB,SAAS;AAC/C"}

package/dist/flatten-D0K8UcQH.d.cts

@@ -0,0 +1,81 @@
+import { S as Awaitable, s as Result } from "./sequence-DDwePRLd.cjs";
+
+//#region src/core/sequenceRecord.d.ts
+type OkValueOf$3<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$3<R> = R extends Result<any, infer E> ? E : never;
+/**
+* Like `sequence`, but for Records/Objects.
+* Short-circuits on the first Err.
+*/
+declare function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any> }>(record: R): Result<{ [K in keyof R]: OkValueOf$3<R[K]> }, ErrValueOf$3<R[keyof R]>>;
+//#endregion
+//#region src/core/collectFirstOk.d.ts
+type OkValueOf$2<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$2<R> = R extends Result<any, infer E> ? E : never;
+/**
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
+*/
+declare function collectFirstOk<const Results extends readonly Result<any, any>[]>(results: Results): Result<OkValueOf$2<Results[number]>, ErrValueOf$2<Results[number]>[]>;
+//#endregion
+//#region src/core/collectFirstOkAsync.d.ts
+type CollectFirstOkAsyncInput$1 = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput$1<I> = ResolvedResult$1<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput$1<I> = ResolvedResult$1<I> extends Result<any, infer E> ? E : never;
+/**
+* Async version of collectFirstOk.
+*
+* - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+* - Processes inputs strictly sequentially (like `for ... of` + `await`).
+* - Returns the first `Ok` and collects all errors if no `Ok` is found.
+*/
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, ErrValueOfInput$1<Inputs[number]>[]>>;
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.d.ts
+type CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;
+/**
+* Parallel version of `collectFirstOkAsync`.
+*
+* - Starts all inputs immediately (Promises or Thunks).
+* - Returns the first `Ok` as soon as it is available.
+* - If no `Ok` is found, returns an `Err` with all error values (in input order).
+* - Rejections are treated as `ErrValue` (`caught as ErrValue`).
+* - If multiple inputs provide an `Ok`, the one that completes first wins.
+*   In case of simultaneous completion, the first observed result wins.
+* - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
+*/
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
+//#endregion
+//#region src/core/collectAllErrors.d.ts
+type OkValueOf$1<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$1<R> = R extends Result<any, infer E> ? E : never;
+type CollectionValues<Results extends readonly Result<any, any>[]> = { -readonly [K in keyof Results]: OkValueOf$1<Results[K]> };
+/**
+* Combines a list of Results.
+* Return Ok(values) only if all are Ok, otherwise Err([errors]).
+*/
+declare function collectAllErrors<const Results extends readonly Result<any, any>[]>(results: Results): Result<CollectionValues<Results>, Array<ErrValueOf$1<Results[number]>>>;
+//#endregion
+//#region src/core/partition.d.ts
+type OkValueOf<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf<R> = R extends Result<any, infer E> ? E : never;
+/**
+* Partitions Results into Ok values and Err errors.
+*/
+declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
+//#endregion
+//#region src/core/flatten.d.ts
+/**
+* Flattens a nested Result.
+* Result<Result<T, E>, E> → Result<T, E>
+* Corresponds to Rust `flatten`.
+*/
+declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
+//#endregion
+export { collectFirstOkAsync as a, collectFirstOkParallelAsync as i, partition as n, collectFirstOk as o, collectAllErrors as r, sequenceRecord as s, flatten as t };
+//# sourceMappingURL=flatten-D0K8UcQH.d.cts.map

package/dist/flatten-D0K8UcQH.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-D0K8UcQH.d.cts","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"mappings":";;;KAKK,WAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,YAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAN1B;;;;AAAA,iBAYZ,cAAA,wCAAsD,CAAA,GAAI,MAAA,cACtE,MAAA,EAAQ,CAAA,GACT,MAAA,eAAqB,CAAA,GAAI,WAAA,CAAU,CAAA,CAAE,CAAA,MAAO,YAAA,CAAW,CAAA,OAAQ,CAAA;;;KCV7D,WAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,YAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;ADL1B;;;;;AAAA,iBCYZ,cAAA,gCAA8C,MAAA,cAC1D,OAAA,EAAS,OAAA,GACV,MAAA,CAAO,WAAA,CAAU,OAAA,WAAkB,YAAA,CAAW,OAAA;;;KCT5C,0BAAA,GACC,OAAA,CAAQ,MAAA,qBACD,SAAA,CAAU,MAAA;AAAA,KAElB,gBAAA,MAAoB,CAAA,2BAA0B,OAAA,CAAQ,CAAA,IAAK,CAAA,SAAU,OAAA,YAAmB,CAAA;AAAA,KACxF,gBAAA,MAAoB,gBAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;AAAA,KACrE,iBAAA,MAAqB,gBAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;;;;;;;;iBASrD,mBAAA,+BAAkD,0BAAA,IACpE,MAAA,EAAQ,MAAA,GACT,OAAA,CAAQ,MAAA,CAAO,gBAAA,CAAe,MAAA,WAAiB,iBAAA,CAAgB,MAAA;;;KCjB7D,wBAAA,GAA2B,OAAA,CAAQ,MAAA,qBAA2B,SAAA,CAAU,MAAA;AAAA,KAExE,cAAA,MAAoB,CAAA,2BAA0B,OAAA,CAAQ,CAAA,IAAK,CAAA,SAAU,OAAA,YAAmB,CAAA;AAAA,KACxF,cAAA,MAAoB,cAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;AAAA,KACrE,eAAA,MAAqB,cAAA,CAAe,CAAA,UAAW,MAAA,iBAAuB,CAAA;;;;;;;;AHJtB;AAAA;;;iBGiB/B,2BAAA,+BAA0D,wBAAA,IAC5E,MAAA,EAAQ,MAAA,GACT,OAAA,CAAQ,MAAA,CAAO,cAAA,CAAe,MAAA,WAAiB,eAAA,CAAgB,MAAA;;;KCpB7D,WAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,YAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KACjD,gBAAA,0BAA0C,MAAA,wCACrB,OAAA,GAAU,WAAA,CAAU,OAAA,CAAQ,CAAA;;;;;iBAOtC,gBAAA,gCAAgD,MAAA,cAC5D,OAAA,EAAS,OAAA,GACV,MAAA,CAAO,gBAAA,CAAiB,OAAA,GAAU,KAAA,CAAM,YAAA,CAAW,OAAA;;;KCbjD,SAAA,MAAe,CAAA,SAAU,MAAA,iBAAuB,CAAA;AAAA,KAChD,UAAA,MAAgB,CAAA,SAAU,MAAA,iBAAuB,CAAA;ALJ1B;;;AAAA,iBKSZ,SAAA,gCAAyC,MAAA,cACrD,OAAA,EAAS,OAAA,IACT,GAAA,EAAK,KAAA,CAAM,SAAA,CAAU,OAAA,YAAmB,IAAA,EAAM,KAAA,CAAM,UAAA,CAAW,OAAA;;;;;ALXvC;;;iBMQZ,OAAA,OAAc,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA"}

package/dist/index.cjs

@@ -1,12 +1,18 @@
-const require_result = require('./result-CY-KIivk.cjs');
-const require_errors = require('./errors-D2EMzJQl.cjs');
-const require_mapOrElse = require('./mapOrElse-H-GvAUka.cjs');
-const require_flatten = require('./flatten-Df9U40nO.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_result = require('./result-BBOGxvSH.cjs');
+const require_errors = require('./errors.cjs');
+const require_swap = require('./swap-BnyMBdD_.cjs');
+const require_flatten = require('./flatten-B_XIkaOK.cjs');
 
 //#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 +30,34 @@ async function task(makeGenerator, onThrow) {
 			return require_result.err(onThrow(caught));
 		}
 		const yielded = step.value;
-		if (!require_result.isResult(yielded)) throw new require_errors.TaskYieldNotResultError(yielded);
+		if (!require_result.isResult(yielded)) {
+			try {
+				await runGeneratorReturn();
+			} catch (caught) {
+				if (!onThrow) throw caught;
+				return require_result.err(onThrow(caught));
+			}
+			throw new require_errors.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 require_result.err(onThrow(caught));
 			}
 			return yielded;
 		}
+		try {
+			await runGeneratorReturn();
+		} catch (caught) {
+			if (!onThrow) throw caught;
+			return require_result.err(onThrow(caught));
+		}
 		throw new require_errors.InvalidResultStateError("task");
 	}
 }
@@ -83,7 +103,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 +145,7 @@ function unwrapErr(result) {
 */
 function expectResult(result, message) {
 	if (result.isOk()) return result.value;
-	if (result.isErr()) throw new require_errors.ExpectOkError(message);
+	if (result.isErr()) throw new require_errors.ExpectOkError(message, result.error);
 	throw new require_errors.InvalidResultStateError("expectResult");
 }
 
@@ -133,10 +157,27 @@ function expectResult(result, message) {
 */
 function expectErr(result, message) {
 	if (result.isErr()) return result.error;
-	if (result.isOk()) throw new require_errors.ExpectErrError(message);
+	if (result.isOk()) throw new require_errors.ExpectErrError(message, result.value);
 	throw new require_errors.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 require_result.ok(data.value);
+		if (data._tag === "Err" && "error" in data) return require_result.err(data.error);
+	}
+	throw new require_errors.InvalidResultStateError("fromSerialized");
+}
+
 //#endregion
 //#region src/core/toPromise.ts
 /**
@@ -190,9 +231,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 require_errors.InvalidResultStateError("contains");
 }
@@ -202,9 +246,12 @@ 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 require_errors.InvalidResultStateError("containsErr");
 }
@@ -216,6 +263,7 @@ exports.ERR_INVALID_RESULT_STATE = require_errors.ERR_INVALID_RESULT_STATE;
 exports.ERR_INVALID_STATE = require_errors.ERR_INVALID_STATE;
 exports.ERR_MATCH_ERR_HANDLER_NOT_RESULT = require_errors.ERR_MATCH_ERR_HANDLER_NOT_RESULT;
 exports.ERR_MATCH_ON_OK = require_errors.ERR_MATCH_ON_OK;
+exports.ERR_MATCH_TAG_MISSING_HANDLER = require_errors.ERR_MATCH_TAG_MISSING_HANDLER;
 exports.ERR_TASK_YIELD_NOT_RESULT = require_errors.ERR_TASK_YIELD_NOT_RESULT;
 exports.ERR_UNWRAP_ERR_ON_OK = require_errors.ERR_UNWRAP_ERR_ON_OK;
 exports.ERR_UNWRAP_ON_ERR = require_errors.ERR_UNWRAP_ON_ERR;
@@ -225,6 +273,7 @@ exports.ExpectOkError = require_errors.ExpectOkError;
 exports.InvalidResultStateError = require_errors.InvalidResultStateError;
 exports.MatchErrHandlerNotResultError = require_errors.MatchErrHandlerNotResultError;
 exports.MatchOnOkError = require_errors.MatchOnOkError;
+exports.MatchTagMissingHandlerError = require_errors.MatchTagMissingHandlerError;
 exports.Ok = require_result.Ok;
 exports.Result = require_result.Result;
 exports.ResultError = require_errors.ResultError;
@@ -233,10 +282,10 @@ exports.TaskYieldNotResultError = require_errors.TaskYieldNotResultError;
 exports.UnwrapErrOnOkError = require_errors.UnwrapErrOnOkError;
 exports.UnwrapOnErrError = require_errors.UnwrapOnErrError;
 exports.all = require_result.all;
-exports.and = require_mapOrElse.and;
-exports.bimap = require_result.bimap;
+exports.and = require_swap.and;
+exports.bimap = require_swap.bimap;
 exports.collectAllErrors = require_flatten.collectAllErrors;
-exports.collectFirstOk = require_result.collectFirstOk;
+exports.collectFirstOk = require_flatten.collectFirstOk;
 exports.collectFirstOkAsync = require_flatten.collectFirstOkAsync;
 exports.collectFirstOkParallelAsync = require_flatten.collectFirstOkParallelAsync;
 exports.combine = require_result.combine;
@@ -245,52 +294,53 @@ exports.containsErr = containsErr;
 exports.err = require_result.err;
 exports.expectErr = expectErr;
 exports.expectResult = expectResult;
-exports.filter = require_result.filter;
-exports.filterAsync = require_result.filterAsync;
-exports.flatMap = require_result.flatMap;
-exports.flatMapAsync = require_result.flatMapAsync;
+exports.filter = require_swap.filter;
+exports.filterAsync = require_swap.filterAsync;
+exports.flatMap = require_swap.flatMap;
+exports.flatMapAsync = require_swap.flatMapAsync;
 exports.flatten = require_flatten.flatten;
-exports.fold = require_mapOrElse.fold;
-exports.foldAsync = require_mapOrElse.foldAsync;
+exports.fold = require_swap.fold;
+exports.foldAsync = require_swap.foldAsync;
 exports.fromNullable = require_result.fromNullable;
 exports.fromPromise = require_result.fromPromise;
+exports.fromSerialized = fromSerialized;
 exports.fromThrowable = require_result.fromThrowable;
 exports.gen = gen;
 exports.isErr = isErr;
 exports.isOk = isOk;
 exports.isResult = require_result.isResult;
-exports.map = require_result.map;
-exports.mapAsync = require_result.mapAsync;
-exports.mapBoth = require_result.mapBoth;
-exports.mapErr = require_result.mapErr;
-exports.mapErrAsync = require_result.mapErrAsync;
-exports.mapOr = require_mapOrElse.mapOr;
-exports.mapOrElse = require_mapOrElse.mapOrElse;
-exports.match = require_result.match;
-exports.matchAsync = require_result.matchAsync;
+exports.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.matchTag = require_result.matchTag;
 exports.ok = require_result.ok;
 exports.okIf = require_result.okIf;
 exports.okIfLazy = require_result.okIfLazy;
-exports.or = require_mapOrElse.or;
-exports.orElse = require_mapOrElse.orElse;
+exports.or = require_swap.or;
+exports.orElse = require_swap.orElse;
 exports.partition = require_flatten.partition;
-exports.recover = require_result.recover;
-exports.recoverWith = require_result.recoverWith;
+exports.recover = require_swap.recover;
+exports.recoverWith = require_swap.recoverWith;
 exports.sequence = require_result.sequence;
 exports.sequenceRecord = require_flatten.sequenceRecord;
-exports.swap = require_result.swap;
-exports.tap = require_result.tap;
-exports.tapAsync = require_result.tapAsync;
+exports.swap = require_swap.swap;
+exports.tap = require_swap.tap;
+exports.tapAsync = require_swap.tapAsync;
 exports.task = task;
 exports.toNullable = toNullable;
 exports.toPromise = toPromise;
 exports.tryAsync = require_result.tryAsync;
-exports.tryCatch = require_result.tryCatch;
-exports.tryCatchAsync = require_result.tryCatchAsync;
+exports.tryCatch = require_swap.tryCatch;
+exports.tryCatchAsync = require_swap.tryCatchAsync;
 exports.tryFn = require_result.tryFn;
-exports.tryMap = require_result.tryMap;
-exports.tryMapAsync = require_result.tryMapAsync;
+exports.tryMap = require_swap.tryMap;
+exports.tryMapAsync = require_swap.tryMapAsync;
 exports.unwrap = unwrap;
 exports.unwrapErr = unwrapErr;
 exports.unwrapOr = unwrapOr;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["input: unknown","step: IteratorResult<Y, R>","err","isResult","ok","TaskYieldNotResultError","InvalidResultStateError","UnwrapOnErrError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","UnwrapErrOnOkError","InvalidResultStateError","ExpectOkError","InvalidResultStateError","ExpectErrError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError"],"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.cjs","names":["err","isResult","ok","TaskYieldNotResultError","InvalidResultStateError","UnwrapOnErrError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","UnwrapErrOnOkError","InvalidResultStateError","ExpectOkError","InvalidResultStateError","ExpectErrError","InvalidResultStateError","ok","err","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError"],"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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"}