@shirudo/result 0.0.6 → 1.0.1

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["ret: any","#error","#matched","#value","isResult","#makeErr","#resolved","mapErr","right","left","errors: Array<AE | BE>","errors: Array<ErrValueOf<Results[number]>>","input: unknown","step: IteratorResult<Y, R>","values: T[]","out: Partial<Out>","errors: Array<ErrValueOfInput<Inputs[number]>>","errors: ErrValue[]","values: T[]","errors: E[]","oks: Array<OkValueOf<Results[number]>>","errs: Array<ErrValueOf<Results[number]>>"],"sources":["../src/core/pipeable.ts","../src/errors.ts","../src/core/matcher.ts","../src/core/map.ts","../src/core/mapErr.ts","../src/core/mapBoth.ts","../src/core/flatMap.ts","../src/core/zip.ts","../src/core/tap.ts","../src/core/filter.ts","../src/core/match.ts","../src/core/recover.ts","../src/core/swap.ts","../src/core/tryCatch.ts","../src/core/tryMap.ts","../src/core/collectFirstOk.ts","../src/core/mapAsync.ts","../src/core/mapErrAsync.ts","../src/core/flatMapAsync.ts","../src/core/tapAsync.ts","../src/core/filterAsync.ts","../src/core/matchAsync.ts","../src/core/tryCatchAsync.ts","../src/core/tryMapAsync.ts","../src/core/result.ts","../src/core/isResult.ts","../src/gen.ts","../src/core/fold.ts","../src/core/foldAsync.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/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts","../src/core/sequence.ts","../src/core/sequenceRecord.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.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":["export type UnaryFunction<Input, Output> = (input: Input) => Output;\nexport type Awaitable<T> = T | Promise<T>;\n\nexport abstract class Pipeable {\n    // -------------------------------------------------------------------------\n    // PIPE (Synchron)\n    // -------------------------------------------------------------------------\n\n    pipe<A>(this: A): A;\n    pipe<A, B>(this: A, ab: UnaryFunction<A, B>): B;\n    pipe<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>): C;\n    pipe<A, B, C, D>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>): D;\n    pipe<A, B, C, D, E>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>\n    ): E;\n    pipe<A, B, C, D, E, F>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>\n    ): F;\n    pipe<A, B, C, D, E, F, G>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>\n    ): G;\n    pipe<A, B, C, D, E, F, G, H>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>\n    ): H;\n    pipe<A, B, C, D, E, F, G, H, I>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>\n    ): I;\n    pipe<A, B, C, D, E, F, G, H, I, J>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>\n    ): J;\n    pipe<A, B, C, D, E, F, G, H, I, J, K>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>\n    ): K;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>\n    ): L;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>\n    ): M;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>\n    ): N;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>\n    ): O;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>,\n        op: UnaryFunction<O, P>\n    ): P;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>,\n        op: UnaryFunction<O, P>,\n        pq: UnaryFunction<P, Q>\n    ): Q;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>,\n        op: UnaryFunction<O, P>,\n        pq: UnaryFunction<P, Q>,\n        qr: UnaryFunction<Q, R>\n    ): R;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>,\n        op: UnaryFunction<O, P>,\n        pq: UnaryFunction<P, Q>,\n        qr: UnaryFunction<Q, R>,\n        rs: UnaryFunction<R, S>\n    ): S;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>,\n        op: UnaryFunction<O, P>,\n        pq: UnaryFunction<P, Q>,\n        qr: UnaryFunction<Q, R>,\n        rs: UnaryFunction<R, S>,\n        st: UnaryFunction<S, T>\n    ): T;\n    pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<B, C>,\n        cd: UnaryFunction<C, D>,\n        de: UnaryFunction<D, E>,\n        ef: UnaryFunction<E, F>,\n        fg: UnaryFunction<F, G>,\n        gh: UnaryFunction<G, H>,\n        hi: UnaryFunction<H, I>,\n        ij: UnaryFunction<I, J>,\n        jk: UnaryFunction<J, K>,\n        kl: UnaryFunction<K, L>,\n        lm: UnaryFunction<L, M>,\n        mn: UnaryFunction<M, N>,\n        no: UnaryFunction<N, O>,\n        op: UnaryFunction<O, P>,\n        pq: UnaryFunction<P, Q>,\n        qr: UnaryFunction<Q, R>,\n        rs: UnaryFunction<R, S>,\n        st: UnaryFunction<S, T>,\n        tu: UnaryFunction<T, U>\n    ): U;\n\n    pipe(this: any, ...ops: Array<UnaryFunction<any, any>>): any {\n        let ret: any = this;\n        for (const op of ops) {\n            ret = op(ret);\n        }\n        return ret;\n    }\n\n    // -------------------------------------------------------------------------\n    // PIPE ASYNC (Asynchron)\n    // -------------------------------------------------------------------------\n\n    pipeAsync<A>(this: A): Promise<A>;\n    pipeAsync<A, B>(this: A, ab: UnaryFunction<A, B>): Promise<Awaited<B>>;\n    pipeAsync<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>): Promise<Awaited<C>>;\n    pipeAsync<A, B, C, D>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>\n    ): Promise<Awaited<D>>;\n    pipeAsync<A, B, C, D, E>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>\n    ): Promise<Awaited<E>>;\n    pipeAsync<A, B, C, D, E, F>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>\n    ): Promise<Awaited<F>>;\n    pipeAsync<A, B, C, D, E, F, G>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>\n    ): Promise<Awaited<G>>;\n    pipeAsync<A, B, C, D, E, F, G, H>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>\n    ): Promise<Awaited<H>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>\n    ): Promise<Awaited<I>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>\n    ): Promise<Awaited<J>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>\n    ): Promise<Awaited<K>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>\n    ): Promise<Awaited<L>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>\n    ): Promise<Awaited<M>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>\n    ): Promise<Awaited<N>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>\n    ): Promise<Awaited<O>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>,\n        op: UnaryFunction<Awaited<O>, P>\n    ): Promise<Awaited<P>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>,\n        op: UnaryFunction<Awaited<O>, P>,\n        pq: UnaryFunction<Awaited<P>, Q>\n    ): Promise<Awaited<Q>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>,\n        op: UnaryFunction<Awaited<O>, P>,\n        pq: UnaryFunction<Awaited<P>, Q>,\n        qr: UnaryFunction<Awaited<Q>, R>\n    ): Promise<Awaited<R>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>,\n        op: UnaryFunction<Awaited<O>, P>,\n        pq: UnaryFunction<Awaited<P>, Q>,\n        qr: UnaryFunction<Awaited<Q>, R>,\n        rs: UnaryFunction<Awaited<R>, S>\n    ): Promise<Awaited<S>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>,\n        op: UnaryFunction<Awaited<O>, P>,\n        pq: UnaryFunction<Awaited<P>, Q>,\n        qr: UnaryFunction<Awaited<Q>, R>,\n        rs: UnaryFunction<Awaited<R>, S>,\n        st: UnaryFunction<Awaited<S>, T>\n    ): Promise<Awaited<T>>;\n    pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(\n        this: A,\n        ab: UnaryFunction<A, B>,\n        bc: UnaryFunction<Awaited<B>, C>,\n        cd: UnaryFunction<Awaited<C>, D>,\n        de: UnaryFunction<Awaited<D>, E>,\n        ef: UnaryFunction<Awaited<E>, F>,\n        fg: UnaryFunction<Awaited<F>, G>,\n        gh: UnaryFunction<Awaited<G>, H>,\n        hi: UnaryFunction<Awaited<H>, I>,\n        ij: UnaryFunction<Awaited<I>, J>,\n        jk: UnaryFunction<Awaited<J>, K>,\n        kl: UnaryFunction<Awaited<K>, L>,\n        lm: UnaryFunction<Awaited<L>, M>,\n        mn: UnaryFunction<Awaited<M>, N>,\n        no: UnaryFunction<Awaited<N>, O>,\n        op: UnaryFunction<Awaited<O>, P>,\n        pq: UnaryFunction<Awaited<P>, Q>,\n        qr: UnaryFunction<Awaited<Q>, R>,\n        rs: UnaryFunction<Awaited<R>, S>,\n        st: UnaryFunction<Awaited<S>, T>,\n        tu: UnaryFunction<Awaited<T>, U>\n    ): Promise<Awaited<U>>;\n\n    async pipeAsync(this: any, ...ops: Array<(a: any) => Awaitable<any>>): Promise<any> {\n        let ret: any = this;\n        for (const op of ops) {\n            ret = await op(ret);\n        }\n        return ret;\n    }\n}\n\n","export const ERR_INVALID_STATE = 'ERR_INVALID_STATE' as const;\nexport const ERR_TASK_YIELD_NOT_RESULT = 'ERR_TASK_YIELD_NOT_RESULT' as const;\nexport const ERR_MATCH_ON_OK = 'ERR_MATCH_ON_OK' as const;\nexport const ERR_UNWRAP_ON_ERR = 'ERR_UNWRAP_ON_ERR' as const;\nexport const ERR_UNWRAP_ERR_ON_OK = 'ERR_UNWRAP_ERR_ON_OK' as const;\nexport const ERR_EXPECT_OK = 'ERR_EXPECT_OK' as const;\nexport const ERR_EXPECT_ERR = 'ERR_EXPECT_ERR' as const;\n\nexport type ResultErrorCode =\n    | typeof ERR_INVALID_STATE\n    | typeof ERR_TASK_YIELD_NOT_RESULT\n    | typeof ERR_MATCH_ON_OK\n    | typeof ERR_UNWRAP_ON_ERR\n    | typeof ERR_UNWRAP_ERR_ON_OK\n    | typeof ERR_EXPECT_OK\n    | typeof ERR_EXPECT_ERR;\n\nconst formatResultErrorMessage = (code: ResultErrorCode, message: string, context?: string): string => {\n    if (context) {\n        return `${code}: ${message} (context: ${context})`;\n    }\n    return `${code}: ${message}`;\n};\n\nexport class ResultError extends Error {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nexport class ResultTypeError extends TypeError {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nconst INVALID_RESULT_STATE_MESSAGE = 'Unreachable: Result is neither Ok nor Err';\n\nexport class InvalidResultStateError extends ResultError {\n    constructor(context?: string) {\n        super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_STATE, context);\n    }\n}\n\nexport class TaskYieldNotResultError extends ResultTypeError {\n    readonly yieldedValue: unknown;\n\n    constructor(yieldedValue: unknown) {\n        super('task() expected yielded values to be Result. Use `yield*` on a Result.', ERR_TASK_YIELD_NOT_RESULT);\n        this.yieldedValue = yieldedValue;\n    }\n}\n\nexport class MatchOnOkError extends ResultTypeError {\n    constructor() {\n        super('match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.', ERR_MATCH_ON_OK);\n    }\n}\n\nexport class UnwrapOnErrError extends ResultTypeError {\n    readonly errorValue: unknown;\n\n    constructor(errorValue: unknown) {\n        super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);\n        this.errorValue = errorValue;\n    }\n}\n\nexport class UnwrapErrOnOkError extends ResultTypeError {\n    readonly okValue: unknown;\n\n    constructor(okValue: unknown) {\n        super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);\n        this.okValue = okValue;\n    }\n}\n\nexport class ExpectOkError extends ResultError {\n    readonly expectedMessage: string;\n\n    constructor(expectedMessage: string) {\n        super(expectedMessage, ERR_EXPECT_OK);\n        this.expectedMessage = expectedMessage;\n    }\n}\n\nexport class ExpectErrError extends ResultError {\n    readonly expectedMessage: string;\n\n    constructor(expectedMessage: string) {\n        super(expectedMessage, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n    }\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\nexport type Ctor<T> = abstract new (...args: any[]) => T;\nexport type TypeGuard<E, A extends E> = (error: E) => error is A;\n\n/**\n * Matcher for Err values (returns an arbitrary return type, e.g. string messages).\n *\n * - `.when(Ctor, handler)` matches via `instanceof`\n * - `.whenGuard(guard, handler)` matches via Type-Guard\n * - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`)\n */\nexport class ErrorMatchBuilder<E, R> {\n    readonly #error: unknown;\n    readonly #matched: boolean;\n    readonly #value: unknown;\n\n    constructor(error: unknown, matched = false, value?: unknown) {\n        this.#error = error;\n        this.#matched = matched;\n        this.#value = value;\n        Object.freeze(this);\n    }\n\n    when<C extends Ctor<E>, R1>(\n        ctor: C,\n        handler: (error: InstanceType<C>) => R1\n    ): ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1> {\n        if (this.#matched) return this as unknown as ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1>;\n\n        if (this.#error instanceof ctor) {\n            return new ErrorMatchBuilder(this.#error, true, handler(this.#error as InstanceType<C>)) as unknown as ErrorMatchBuilder<\n                Exclude<E, InstanceType<C>>,\n                R | R1\n            >;\n        }\n\n        return this as unknown as ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1>;\n    }\n\n    whenGuard<A extends E, R1>(\n        guard: TypeGuard<E, A>,\n        handler: (error: A) => R1\n    ): ErrorMatchBuilder<Exclude<E, A>, R | R1> {\n        if (this.#matched) return this as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n\n        const error = this.#error as E;\n        if (guard(error)) {\n            return new ErrorMatchBuilder(this.#error, true, handler(error)) as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n        }\n\n        return this as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n    }\n\n    otherwise<R2>(handler: (error: E) => R2): R | R2 {\n        if (this.#matched) return this.#value as R;\n        return handler(this.#error as E);\n    }\n\n    run(this: ErrorMatchBuilder<never, R>): R {\n        if (this.#matched) return this.#value as R;\n        throw this.#error;\n    }\n}\n\ntype OkOfReturn<R> = R extends Result<infer T, any> ? T : never;\ntype ErrOfReturn<R> = R extends Result<any, infer E> ? E : R;\n\ntype ErrFactory = <E>(error: E) => Result<never, E>;\n\nfunction isResult(value: unknown): value is Result<any, any> {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        'isOk' in value &&\n        typeof (value as any).isOk === 'function' &&\n        'isErr' in value &&\n        typeof (value as any).isErr === 'function'\n    );\n}\n\n/**\n * Matcher for `Result` Errors, which returns a `Result` again.\n *\n * Handlers may:\n * - return a `Result` (is returned directly)\n * - return an Error value (is automatically wrapped into `Err(error)`)\n */\nexport class ErrMatchBuilder<T, E, OutT, OutE> {\n    readonly #makeErr: ErrFactory;\n    readonly #error: unknown;\n    readonly #resolved: Result<any, any> | undefined;\n\n    private constructor(makeErr: ErrFactory, error: unknown, resolved?: Result<any, any>) {\n        this.#makeErr = makeErr;\n        this.#error = error;\n        this.#resolved = resolved;\n        Object.freeze(this);\n    }\n\n    static fromResult<T, E>(result: Result<T, E>, makeErr: ErrFactory): ErrMatchBuilder<T, E, never, never> {\n        if (result.isOk()) return new ErrMatchBuilder<T, E, never, never>(makeErr, undefined, result);\n        if (result.isErr()) return new ErrMatchBuilder<T, E, never, never>(makeErr, result.error);\n        throw new InvalidResultStateError('ErrMatchBuilder.fromResult');\n    }\n\n    when<C extends Ctor<E>, R1>(\n        ctor: C,\n        handler: (error: InstanceType<C>) => R1\n    ): ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>> {\n        if (this.#resolved) {\n            return this as unknown as ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n        }\n\n        if (this.#error instanceof ctor) {\n            const out = handler(this.#error as InstanceType<C>);\n            const resolved = isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R1>);\n            return new ErrMatchBuilder(this.#makeErr, this.#error, resolved) as unknown as ErrMatchBuilder<\n                T,\n                Exclude<E, InstanceType<C>>,\n                OutT | OkOfReturn<R1>,\n                OutE | ErrOfReturn<R1>\n            >;\n        }\n\n        return this as unknown as ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n    }\n\n    whenGuard<A extends E, R1>(\n        guard: TypeGuard<E, A>,\n        handler: (error: A) => R1\n    ): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>> {\n        if (this.#resolved) return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n\n        const error = this.#error as E;\n        if (guard(error)) {\n            const out = handler(error);\n            const resolved = isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R1>);\n            return new ErrMatchBuilder(this.#makeErr, this.#error, resolved) as unknown as ErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfReturn<R1>,\n                OutE | ErrOfReturn<R1>\n            >;\n        }\n\n        return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n    }\n\n    otherwise<R2>(handler: (error: E) => R2): Result<T | OutT | OkOfReturn<R2>, OutE | ErrOfReturn<R2>> {\n        if (this.#resolved) return this.#resolved as Result<T | OutT | OkOfReturn<R2>, OutE | ErrOfReturn<R2>>;\n\n        const out = handler(this.#error as E);\n        return (isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R2>)) as Result<\n            T | OutT | OkOfReturn<R2>,\n            OutE | ErrOfReturn<R2>\n        >;\n    }\n\n    run(this: ErrMatchBuilder<T, never, OutT, OutE>): Result<T | OutT, OutE> {\n        if (this.#resolved) return this.#resolved as Result<T | OutT, OutE>;\n        throw this.#error;\n    }\n}\n","import type { Result } from './result';\nimport { ok } from './result';\n\n/**\n * Transforms the value (Ok case).\n * Corresponds to Rust `map`.\n */\nexport function map<T, E, U>(project: (value: T) => U) {\n    return (source: Result<T, E>): Result<U, E> => {\n        if (source.isOk()) {\n            return ok(project(source.value));\n        }\n        return source as unknown as Result<U, E>;\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Transforms the error (Err case).\n * Corresponds to Rust `map_err`.\n */\nexport function mapErr<T, E, F>(project: (error: E) => F) {\n    return (source: Result<T, E>): Result<T, F> => {\n        if (source.isErr()) {\n            return err(project(source.error));\n        }\n        return source as unknown as Result<T, F>;\n    };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms both the Ok value and the Err error.\n * Corresponds to FP `bimap` / `mapBoth`.\n */\nexport function mapBoth<T, E, U, F>(mapOk: (value: T) => U, mapErr: (error: E) => F) {\n    return (source: Result<T, E>): Result<U, F> => {\n        if (source.isOk()) {\n            return ok<U, F>(mapOk(source.value));\n        }\n        if (source.isErr()) {\n            return err<F, U>(mapErr(source.error));\n        }\n        throw new InvalidResultStateError('mapBoth');\n    };\n}\n\n/**\n * Alias for `mapBoth`.\n */\nexport const bimap = mapBoth;\n","import type { Result } from './result';\n\n/**\n * Chains another operation that returns a Result.\n * Corresponds to Rust `and_then` or JS `flatMap`.\n */\nexport function flatMap<T, E, U>(project: (value: T) => Result<U, E>) {\n    return (source: Result<T, E>): Result<U, E> => {\n        if (source.isOk()) {\n            return project(source.value);\n        }\n        return source as unknown as Result<U, E>;\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\nimport { err, ok } from './result';\n\nfunction zipImpl<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE> {\n    if (left.isErr()) return left as unknown as Result<[A, B], AE | BE>;\n    if (right.isErr()) return right as unknown as Result<[A, B], AE | BE>;\n    if (left.isOk() && right.isOk()) return ok<[A, B], AE | BE>([left.value, right.value]);\n    throw new InvalidResultStateError('zip');\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * Short-circuits on the first Err (left before right).\n */\nexport function zip<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE>;\nexport function zip<A, AE, B, BE>(right: Result<B, BE>): (left: Result<A, AE>) => Result<[A, B], AE | BE>;\nexport function zip(...args: unknown[]): unknown {\n    if (args.length === 1) {\n        const right = args[0] as Result<any, any>;\n        return (left: Result<any, any>) => zipImpl(left, right);\n    }\n    const [left, right] = args as [Result<any, any>, Result<any, any>];\n    return zipImpl(left, right);\n}\n\nfunction combineImpl<A, AE, B, BE>(\n    left: Result<A, AE>,\n    right: Result<B, BE>\n): Result<[A, B], Array<AE | BE>> {\n    if (left.isOk() && right.isOk()) {\n        return ok<[A, B], Array<AE | BE>>([left.value, right.value]);\n    }\n\n    const errors: Array<AE | BE> = [];\n    if (left.isErr()) errors.push(left.error as AE | BE);\n    if (right.isErr()) errors.push(right.error as AE | BE);\n\n    return err<Array<AE | BE>, [A, B]>(errors);\n}\n\n/**\n * Combines two Results and collects errors.\n * - Ok only if both are Ok\n * - Err([errors]) if at least one is Err (left before right)\n */\nexport function combine<A, AE, B, BE>(\n    left: Result<A, AE>,\n    right: Result<B, BE>\n): Result<[A, B], Array<AE | BE>>;\nexport function combine<A, AE, B, BE>(\n    right: Result<B, BE>\n): (left: Result<A, AE>) => Result<[A, B], Array<AE | BE>>;\nexport function combine(...args: unknown[]): unknown {\n    if (args.length === 1) {\n        const right = args[0] as Result<any, any>;\n        return (left: Result<any, any>) => combineImpl(left, right);\n    }\n    const [left, right] = args as [Result<any, any>, Result<any, any>];\n    return combineImpl(left, right);\n}\n","import type { Result } from './result';\n\n/**\n * Executes a side effect (logging, debugging) without changing the Result.\n * Corresponds to Rust `inspect` / `inspect_err`.\n */\nexport function tap<T, E>(observer: { ok?: (val: T) => void; err?: (e: E) => void }) {\n    return (source: Result<T, E>): Result<T, E> => {\n        if (source.isOk() && observer.ok) observer.ok(source.value);\n        if (source.isErr() && observer.err) observer.err(source.error);\n        return source;\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Checks a condition. If false, the Result becomes Err.\n * Corresponds to Rust `filter` (partially).\n */\nexport function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E) {\n    return (source: Result<T, E>): Result<T, E> => {\n        if (source.isOk()) {\n            if (predicate(source.value)) {\n                return source;\n            }\n            return err(errorFn());\n        }\n        return source;\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Resolves the Result. The end of the pipe.\n * Corresponds to Rust `match`.\n */\nexport function match<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('match');\n    };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Recover: converts Err to Ok(defaultValue).\n * Result is guaranteed to be Ok → Error type becomes `never`.\n */\nexport function recover<T, E, F>(defaultValue: F) {\n    return (source: Result<T, E>): Result<T | F, never> => {\n        if (source.isOk()) return source as unknown as Result<T | F, never>;\n        if (source.isErr()) return ok(defaultValue);\n        throw new InvalidResultStateError('recover');\n    };\n}\n\n/**\n * Like `recover`, but calculates the default value based on the error.\n */\nexport function recoverWith<T, E, F>(fn: (error: E) => F) {\n    return (source: Result<T, E>): Result<T | F, never> => {\n        if (source.isOk()) return source as unknown as Result<T | F, never>;\n        if (source.isErr()) return ok(fn(source.error));\n        throw new InvalidResultStateError('recoverWith');\n    };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Swaps Ok and Err.\n * Result<T, E> → Result<E, T>\n */\nexport function swap<T, E>(result: Result<T, E>): Result<E, T> {\n    if (result.isOk()) {\n        return err<T, E>(result.value);\n    }\n    if (result.isErr()) {\n        return ok<E, T>(result.error);\n    }\n    throw new InvalidResultStateError('swap');\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Executes a function and catches exceptions.\n * Converts exceptions into Result<E>.\n * Corresponds to Rust `Result::from` for fallible operations.\n */\nexport function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E) {\n    return (source: Result<any, any>): Result<T, E> => {\n        if (source.isErr()) return source as unknown as Result<T, E>;\n\n        try {\n            return ok(fn());\n        } catch (error) {\n            return err(errorMapper ? errorMapper(error) : error as E);\n        }\n    };\n}","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Like `map`, but catches exceptions and converts them to Err.\n */\nexport function tryMap<T, E, U, F = unknown>(\n    project: (value: T) => U,\n    errorMapper?: (error: unknown) => F\n) {\n    return (source: Result<T, E>): Result<U, E | F> => {\n        if (source.isErr()) {\n            return source as unknown as Result<U, E | F>;\n        }\n\n        try {\n            if (source.isOk()) return ok<U, E | F>(project(source.value));\n            throw new InvalidResultStateError('tryMap');\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\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 } from './result';\n\n/**\n * Async version of map.\n */\nexport function mapAsync<T, E, U>(project: (value: T) => Promise<U>) {\n    return async (source: Result<T, E>): Promise<Result<U, E>> => {\n        if (source.isOk()) {\n            return ok(await project(source.value));\n        }\n        return source as unknown as Result<U, E>;\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Async version of mapErr.\n */\nexport function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>) {\n    return async (source: Result<T, E>): Promise<Result<T, F>> => {\n        if (source.isErr()) {\n            return err(await project(source.error));\n        }\n        return source as unknown as Result<T, F>;\n    };\n}\n","import type { Result } from './result';\n\n/**\n * Async version of flatMap.\n */\nexport function flatMapAsync<T, E, U>(project: (value: T) => Promise<Result<U, E>>) {\n    return async (source: Result<T, E>): Promise<Result<U, E>> => {\n        if (source.isOk()) {\n            return await project(source.value);\n        }\n        return source as unknown as Result<U, E>;\n    };\n}\n","import type { Result } from './result';\n\n/**\n * Async version of tap.\n */\nexport function tapAsync<T, E>(observer: { ok?: (val: T) => Promise<void>; err?: (e: E) => Promise<void> }) {\n    return async (source: Result<T, E>): Promise<Result<T, E>> => {\n        if (source.isOk() && observer.ok) await observer.ok(source.value);\n        if (source.isErr() && observer.err) await observer.err(source.error);\n        return source;\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Async version of filter.\n */\nexport function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>) {\n    return async (source: Result<T, E>): Promise<Result<T, E>> => {\n        if (source.isOk()) {\n            if (await predicate(source.value)) {\n                return source;\n            }\n            return err(await errorFn());\n        }\n        return source;\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of match.\n */\nexport function matchAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('matchAsync');\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Async version of tryCatch.\n */\nexport function tryCatchAsync<T, E = unknown>(\n    fn: () => Promise<T>,\n    errorMapper?: (error: unknown) => E\n) {\n    return async (source: Result<any, any>): Promise<Result<T, E>> => {\n        if (source.isErr()) return source as unknown as Result<T, E>;\n\n        try {\n            return ok(await fn());\n        } catch (error) {\n            return err(errorMapper ? errorMapper(error) : error as E);\n        }\n    };\n}","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of tryMap.\n */\nexport function tryMapAsync<T, E, U, F = unknown>(\n    project: (value: T) => Promise<U>,\n    errorMapper?: (error: unknown) => F\n) {\n    return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n        if (source.isErr()) {\n            return source as unknown as Result<U, E | F>;\n        }\n\n        try {\n            if (source.isOk()) return ok<U, E | F>(await project(source.value));\n            throw new InvalidResultStateError('tryMapAsync');\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\n}\n","import { Pipeable } from './pipeable';\nimport { ErrMatchBuilder, ErrorMatchBuilder } from './matcher';\nimport { InvalidResultStateError, MatchOnOkError } from '../errors';\n\n// Re-export pipe operators for convenience\nexport { map } from './map';\nexport { mapErr } from './mapErr';\nexport { bimap, mapBoth } from './mapBoth';\nexport { flatMap } from './flatMap';\nexport { zip, combine } from './zip';\nexport { tap } from './tap';\nexport { filter } from './filter';\nexport { match } from './match';\nexport { recover, recoverWith } from './recover';\nexport { swap } from './swap';\nexport { tryCatch } from './tryCatch';\nexport { tryMap } from './tryMap';\nexport { collectFirstOk } from './collectFirstOk';\n\n// Async variants\nexport { mapAsync } from './mapAsync';\nexport { mapErrAsync } from './mapErrAsync';\nexport { flatMapAsync } from './flatMapAsync';\nexport { tapAsync } from './tapAsync';\nexport { filterAsync } from './filterAsync';\nexport { matchAsync } from './matchAsync';\nexport { tryCatchAsync } from './tryCatchAsync';\nexport { tryMapAsync } from './tryMapAsync';\n\n// --- 1. Helper Types ---\n\n// An operator is a function that takes a Result and returns something else.\nexport type OperatorFunction<T, E, R> = (input: Result<T, E>) => R;\nexport type { Awaitable } from './pipeable';\nexport type AsyncOperatorFunction<T, E, R> = (input: Result<T, E>) => Promise<R>;\n\n// --- 2. Result Types ---\n\nexport type ResultType<T, E> = { readonly _tag: 'Ok'; readonly value: T } | { readonly _tag: 'Err'; readonly error: E };\n\nexport type Result<T, E> = Ok<T, E> | Err<T, E>;\ntype OkValue<R> = R extends { readonly _tag: 'Ok'; readonly value: infer T } ? T : never;\n\nabstract class ResultBase extends Pipeable {\n    abstract readonly _tag: 'Ok' | 'Err';\n    abstract readonly value: unknown;\n    abstract readonly error: unknown;\n\n    // Basic helpers for internal access in operators\n    isOk<T, E>(this: Result<T, E>): this is Ok<T, E> {\n        return this._tag === 'Ok';\n    }\n\n    isErr<T, E>(this: Result<T, E>): this is Err<T, E> {\n        return this._tag === 'Err';\n    }\n\n    unwrapOr<T, E>(this: Result<T, E>, defaultValue: T): T {\n        return this._tag === 'Ok' ? this.value : defaultValue;\n    }\n\n    /**\n     * Folds the Result into a single value by applying one of two functions.\n     */\n    fold<T, E, R1, R2 = R1>(this: Result<T, E>, onOk: (value: T) => R1, onErr: (error: E) => R2): R1 | R2 {\n        if (this._tag === 'Ok') return onOk(this.value);\n        if (this._tag === 'Err') return onErr(this.error);\n        throw new InvalidResultStateError('Result.fold');\n    }\n\n    /**\n     * Enables `yield* result` in generators (Do-notation).\n     *\n     * The iterator yields the `Result` itself; the runner (see `task`) decides:\n     * - Ok  → sends back the Ok value (`next(value)`), `yield*` yields `T`\n     * - Err → aborts and returns the Err Result\n     */\n    *[Symbol.iterator](): Generator<unknown, OkValue<this>, unknown> {\n        return (yield this) as OkValue<this>;\n    }\n\n    /**\n     * Matches on the Err value via `.when(...)` chain.\n     *\n     * Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,\n     * e.g. inside `if (result.isErr()) { ... }`.\n     */\n    match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never> {\n        if (this._tag === 'Err') return new ErrorMatchBuilder(this.error);\n        throw new MatchOnOkError();\n    }\n\n    /**\n     * Matches on the Err value, but normalizes every branch to a `Result`:\n     * - Handlers may return a `Result` (is returned directly)\n     * - or an Error value (is wrapped into `Err(error)`)\n     */\n    matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never> {\n        const makeErr = <ErrValue>(error: ErrValue) => err<ErrValue, never>(error);\n        return ErrMatchBuilder.fromResult(this, makeErr);\n    }\n\n    /**\n     * Serializes the Result into a simple object format.\n     * Preserves the original types.\n     */\n    serialize<T, E>(this: Result<T, E>): { isSuccess: boolean; data?: T; error?: E } {\n        if (this._tag === 'Ok') return { isSuccess: true, data: this.value };\n        return { isSuccess: false, error: this.error };\n    }\n\n    /**\n     * Serializes the Result into a user-friendly format.\n     * Converts Errors to readable strings.\n     */\n    toUserFriendly<T, E>(this: Result<T, E>): { isSuccess: boolean; data?: T; error?: string } {\n        if (this._tag === 'Ok') return { isSuccess: true, data: this.value };\n\n        const error = this.error;\n        const errorMessage =\n            error && typeof error === 'object' && 'message' in error ? (error as any).message : String(error);\n\n        return { isSuccess: false, error: errorMessage };\n    }\n}\n\nexport class Ok<T, E = never> extends ResultBase {\n    readonly _tag = 'Ok' as const;\n    readonly value: T;\n    readonly error = undefined;\n\n    constructor(value: T) {\n        super();\n        this.value = value;\n        Object.freeze(this);\n    }\n}\n\nexport class Err<T = never, E = never> extends ResultBase {\n    readonly _tag = 'Err' as const;\n    readonly value = undefined;\n    readonly error: E;\n\n    constructor(error: E) {\n        super();\n        this.error = error;\n        Object.freeze(this);\n    }\n}\n\nexport function ok(): Result<void, never>;\nexport function ok<T, E = never>(value: T): Result<T, E>;\nexport function ok<T, E = never>(value?: T): Result<T, E> {\n    return new Ok<T, E>(value as T);\n}\n\nexport function err<E, T = never>(error: E): Result<T, E> {\n    return new Err<T, E>(error);\n}\n\nexport function okIf<T, E>(condition: boolean, okValue: T, errValue: E): Result<T, E> {\n    return condition ? ok<T, E>(okValue) : err<E, T>(errValue);\n}\n\nexport function okIfLazy<T, E>(condition: boolean, okFn: () => T, errFn: () => E): Result<T, E> {\n    return condition ? ok<T, E>(okFn()) : err<E, T>(errFn());\n}\n\nexport function fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E> {\n    if (value === null || value === undefined) {\n        return err<E, NonNullable<T>>(error);\n    }\n    return ok<NonNullable<T>, E>(value as NonNullable<T>);\n}\n\nexport function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;\nexport function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>> {\n    try {\n        const value = await promise;\n        return ok(value);\n    } catch (error) {\n        try {\n            return err(errorMapper ? errorMapper(error) : (error as E));\n        } catch (mapperError) {\n            return err(mapperError as E);\n        }\n    }\n}\n\nexport function tryFn<T>(fn: () => T): Result<T, unknown> {\n    try {\n        return ok(fn());\n    } catch (error) {\n        return err(error);\n    }\n}\n\nexport const Result = {\n    ok,\n    err,\n    fromNullable,\n    fromPromise,\n    try: tryFn,\n};\n","import type { Result } from './result';\n\n/**\n * Checks whether a value is a Result.\n * Pure function alternative for runtime checks.\n */\nexport function isResult(value: unknown): value is Result<any, any> {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        'isOk' in value &&\n        typeof (value as { isOk?: unknown }).isOk === 'function' &&\n        'isErr' in value &&\n        typeof (value as { isErr?: unknown }).isErr === 'function'\n    );\n}\n","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 } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('fold');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('foldAsync');\n    };\n}\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';\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    return defaultValue;\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 } 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    throw new ExpectOkError(message);\n}\n","import type { Result } from './result';\nimport { ExpectErrError } 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    throw new ExpectErrError(message);\n}\n","import type { Result } from './result';\n\n/**\n * Combines two Results. Returns the second one only if the first is Ok.\n * Corresponds to Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n    return result.isOk() ? other : result as unknown as Result<U, E>;\n}","import type { Result } from './result';\n\n/**\n * Fallback to another Result if the first is Err.\n * Corresponds to Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n    return result.isOk() ? result as unknown as Result<T, F> : other;\n}","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback with a function that returns a Result.\n * Corresponds to Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\n\n/**\n * Transforms the value or returns a default value.\n * Corresponds to Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    return defaultValue;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or calculates a default value using a function.\n * Corresponds to Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultFn(result.error);\n    throw new InvalidResultStateError('mapOrElse');\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines a list of Results into a single Result of a list.\n * Short-circuits on the first Err.\n * Analogous to Rust `collect::<Result<Vec<_>, _>>()`.\n */\nexport function sequence<T, E>(results: readonly Result<T, E>[]): Result<T[], E> {\n    const values: T[] = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            values.push(result.value);\n            continue;\n        }\n        if (result.isErr()) return result as unknown as Result<T[], E>;\n        throw new InvalidResultStateError('sequence');\n    }\n\n    return ok(values);\n}\n\n/**\n * Alias for `sequence`.\n */\nexport function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E> {\n    return sequence(results);\n}\n","import type { Result } from './result';\nimport { ok } 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 * Like `sequence`, but for Records/Objects.\n * Short-circuits on the first Err.\n */\nexport function sequenceRecord<const R extends Record<string, 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 Object.keys(record) as Array<keyof R>) {\n        const result = record[key];\n        if (!result) continue;\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 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        try {\n            const result = await (typeof input === 'function' ? input() : input);\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        } catch (error) {\n            // If the Promise itself rejects, we treat it as an Error\n            errors.push(error as ErrValueOfInput<Inputs[number]>);\n        }\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                    errors.push(new InvalidResultStateError('collectFirstOkParallelAsync') as ErrValue);\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\n/**\n * Combines a list of Results.\n * Return Ok(values) only if all are Ok, otherwise Err([errors]).\n */\nexport function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Result<T[], E[]> {\n    const values: T[] = [];\n    const errors: E[] = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            values.push(result.value);\n            continue;\n        }\n        if (result.isErr()) {\n            errors.push(result.error);\n            continue;\n        }\n        throw new InvalidResultStateError('collectAllErrors');\n    }\n\n    return errors.length === 0 ? ok(values) : err<E[], T[]>(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';\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    return result as unknown as Result<T, E>;\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';\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    return null;\n}\n","import type { Ok, Result } from './result';\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    return result.isOk();\n}\n","import type { Err, Result } from './result';\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    return result.isErr();\n}\n","import type { Result } from './result';\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 false;\n    return result.value === value;\n}\n","import type { Result } from './result';\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 false;\n    return result.error === error;\n}\n"],"mappings":";AAGA,IAAsB,WAAtB,MAA+B;CAyQ3B,KAAgB,GAAG,KAA0C;EACzD,IAAIA,MAAW;AACf,OAAK,MAAM,MAAM,IACb,OAAM,GAAG,IAAI;AAEjB,SAAO;;CAgRX,MAAM,UAAqB,GAAG,KAAsD;EAChF,IAAIA,MAAW;AACf,OAAK,MAAM,MAAM,IACb,OAAM,MAAM,GAAG,IAAI;AAEvB,SAAO;;;;;;ACtiBf,MAAa,oBAAoB;AACjC,MAAa,4BAA4B;AACzC,MAAa,kBAAkB;AAC/B,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AACpC,MAAa,gBAAgB;AAC7B,MAAa,iBAAiB;AAW9B,MAAM,4BAA4B,MAAuB,SAAiB,YAA6B;AACnG,KAAI,QACA,QAAO,GAAG,KAAK,IAAI,QAAQ,aAAa,QAAQ;AAEpD,QAAO,GAAG,KAAK,IAAI;;AAGvB,IAAa,cAAb,cAAiC,MAAM;CACnC,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;AAClE,QAAM,yBAAyB,MAAM,SAAS,QAAQ,CAAC;AACvD,OAAK,OAAO;AACZ,OAAK,UAAU;AACf,OAAK,OAAO,IAAI,OAAO;AACvB,SAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;;AAIzD,IAAa,kBAAb,cAAqC,UAAU;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;AAClE,QAAM,yBAAyB,MAAM,SAAS,QAAQ,CAAC;AACvD,OAAK,OAAO;AACZ,OAAK,UAAU;AACf,OAAK,OAAO,IAAI,OAAO;AACvB,SAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;;AAIzD,MAAM,+BAA+B;AAErC,IAAa,0BAAb,cAA6C,YAAY;CACrD,YAAY,SAAkB;AAC1B,QAAM,8BAA8B,mBAAmB,QAAQ;;;AAIvE,IAAa,0BAAb,cAA6C,gBAAgB;CACzD,AAAS;CAET,YAAY,cAAuB;AAC/B,QAAM,0EAA0E,0BAA0B;AAC1G,OAAK,eAAe;;;AAI5B,IAAa,iBAAb,cAAoC,gBAAgB;CAChD,cAAc;AACV,QAAM,uFAAuF,gBAAgB;;;AAIrH,IAAa,mBAAb,cAAsC,gBAAgB;CAClD,AAAS;CAET,YAAY,YAAqB;AAC7B,QAAM,2BAA2B,OAAO,WAAW,IAAI,kBAAkB;AACzE,OAAK,aAAa;;;AAI1B,IAAa,qBAAb,cAAwC,gBAAgB;CACpD,AAAS;CAET,YAAY,SAAkB;AAC1B,QAAM,6BAA6B,OAAO,QAAQ,IAAI,qBAAqB;AAC3E,OAAK,UAAU;;;AAIvB,IAAa,gBAAb,cAAmC,YAAY;CAC3C,AAAS;CAET,YAAY,iBAAyB;AACjC,QAAM,iBAAiB,cAAc;AACrC,OAAK,kBAAkB;;;AAI/B,IAAa,iBAAb,cAAoC,YAAY;CAC5C,AAAS;CAET,YAAY,iBAAyB;AACjC,QAAM,iBAAiB,eAAe;AACtC,OAAK,kBAAkB;;;;;;;;;;;;;AC5F/B,IAAa,oBAAb,MAAa,kBAAwB;CACjC,CAASC;CACT,CAASC;CACT,CAASC;CAET,YAAY,OAAgB,UAAU,OAAO,OAAiB;AAC1D,QAAKF,QAAS;AACd,QAAKC,UAAW;AAChB,QAAKC,QAAS;AACd,SAAO,OAAO,KAAK;;CAGvB,KACI,MACA,SACsD;AACtD,MAAI,MAAKD,QAAU,QAAO;AAE1B,MAAI,MAAKD,iBAAkB,KACvB,QAAO,IAAI,kBAAkB,MAAKA,OAAQ,MAAM,QAAQ,MAAKA,MAA0B,CAAC;AAM5F,SAAO;;CAGX,UACI,OACA,SACwC;AACxC,MAAI,MAAKC,QAAU,QAAO;EAE1B,MAAM,QAAQ,MAAKD;AACnB,MAAI,MAAM,MAAM,CACZ,QAAO,IAAI,kBAAkB,MAAKA,OAAQ,MAAM,QAAQ,MAAM,CAAC;AAGnE,SAAO;;CAGX,UAAc,SAAmC;AAC7C,MAAI,MAAKC,QAAU,QAAO,MAAKC;AAC/B,SAAO,QAAQ,MAAKF,MAAY;;CAGpC,MAA0C;AACtC,MAAI,MAAKC,QAAU,QAAO,MAAKC;AAC/B,QAAM,MAAKF;;;AASnB,SAASG,WAAS,OAA2C;AACzD,QACI,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,OAAQ,MAAc,SAAS,cAC/B,WAAW,SACX,OAAQ,MAAc,UAAU;;;;;;;;;AAWxC,IAAa,kBAAb,MAAa,gBAAkC;CAC3C,CAASC;CACT,CAASJ;CACT,CAASK;CAET,AAAQ,YAAY,SAAqB,OAAgB,UAA6B;AAClF,QAAKD,UAAW;AAChB,QAAKJ,QAAS;AACd,QAAKK,WAAY;AACjB,SAAO,OAAO,KAAK;;CAGvB,OAAO,WAAiB,QAAsB,SAA0D;AACpG,MAAI,OAAO,MAAM,CAAE,QAAO,IAAI,gBAAoC,SAAS,QAAW,OAAO;AAC7F,MAAI,OAAO,OAAO,CAAE,QAAO,IAAI,gBAAoC,SAAS,OAAO,MAAM;AACzF,QAAM,IAAI,wBAAwB,6BAA6B;;CAGnE,KACI,MACA,SAC8F;AAC9F,MAAI,MAAKA,SACL,QAAO;AAGX,MAAI,MAAKL,iBAAkB,MAAM;GAC7B,MAAM,MAAM,QAAQ,MAAKA,MAA0B;GACnD,MAAM,WAAWG,WAAS,IAAI,GAAG,MAAM,MAAKC,QAAS,IAAuB;AAC5E,UAAO,IAAI,gBAAgB,MAAKA,SAAU,MAAKJ,OAAQ,SAAS;;AAQpE,SAAO;;CAGX,UACI,OACA,SACgF;AAChF,MAAI,MAAKK,SAAW,QAAO;EAE3B,MAAM,QAAQ,MAAKL;AACnB,MAAI,MAAM,MAAM,EAAE;GACd,MAAM,MAAM,QAAQ,MAAM;GAC1B,MAAM,WAAWG,WAAS,IAAI,GAAG,MAAM,MAAKC,QAAS,IAAuB;AAC5E,UAAO,IAAI,gBAAgB,MAAKA,SAAU,MAAKJ,OAAQ,SAAS;;AAQpE,SAAO;;CAGX,UAAc,SAAsF;AAChG,MAAI,MAAKK,SAAW,QAAO,MAAKA;EAEhC,MAAM,MAAM,QAAQ,MAAKL,MAAY;AACrC,SAAQG,WAAS,IAAI,GAAG,MAAM,MAAKC,QAAS,IAAuB;;CAMvE,MAAyE;AACrE,MAAI,MAAKC,SAAW,QAAO,MAAKA;AAChC,QAAM,MAAKL;;;;;;;;;;AC3JnB,SAAgB,IAAa,SAA0B;AACnD,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,CACb,QAAO,GAAG,QAAQ,OAAO,MAAM,CAAC;AAEpC,SAAO;;;;;;;;;;ACLf,SAAgB,OAAgB,SAA0B;AACtD,SAAQ,WAAuC;AAC3C,MAAI,OAAO,OAAO,CACd,QAAO,IAAI,QAAQ,OAAO,MAAM,CAAC;AAErC,SAAO;;;;;;;;;;ACJf,SAAgB,QAAoB,OAAwB,UAAyB;AACjF,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,CACb,QAAO,GAAS,MAAM,OAAO,MAAM,CAAC;AAExC,MAAI,OAAO,OAAO,CACd,QAAO,IAAUM,SAAO,OAAO,MAAM,CAAC;AAE1C,QAAM,IAAI,wBAAwB,UAAU;;;;;;AAOpD,MAAa,QAAQ;;;;;;;;ACjBrB,SAAgB,QAAiB,SAAqC;AAClE,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,CACb,QAAO,QAAQ,OAAO,MAAM;AAEhC,SAAO;;;;;;ACPf,SAAS,QAAsB,MAAqB,OAA+C;AAC/F,KAAI,KAAK,OAAO,CAAE,QAAO;AACzB,KAAI,MAAM,OAAO,CAAE,QAAO;AAC1B,KAAI,KAAK,MAAM,IAAI,MAAM,MAAM,CAAE,QAAO,GAAoB,CAAC,KAAK,OAAO,MAAM,MAAM,CAAC;AACtF,OAAM,IAAI,wBAAwB,MAAM;;AAS5C,SAAgB,IAAI,GAAG,MAA0B;AAC7C,KAAI,KAAK,WAAW,GAAG;EACnB,MAAMC,UAAQ,KAAK;AACnB,UAAQ,WAA2B,QAAQC,QAAMD,QAAM;;CAE3D,MAAM,CAAC,MAAM,SAAS;AACtB,QAAO,QAAQ,MAAM,MAAM;;AAG/B,SAAS,YACL,MACA,OAC8B;AAC9B,KAAI,KAAK,MAAM,IAAI,MAAM,MAAM,CAC3B,QAAO,GAA2B,CAAC,KAAK,OAAO,MAAM,MAAM,CAAC;CAGhE,MAAME,SAAyB,EAAE;AACjC,KAAI,KAAK,OAAO,CAAE,QAAO,KAAK,KAAK,MAAiB;AACpD,KAAI,MAAM,OAAO,CAAE,QAAO,KAAK,MAAM,MAAiB;AAEtD,QAAO,IAA4B,OAAO;;AAe9C,SAAgB,QAAQ,GAAG,MAA0B;AACjD,KAAI,KAAK,WAAW,GAAG;EACnB,MAAMF,UAAQ,KAAK;AACnB,UAAQ,WAA2B,YAAYC,QAAMD,QAAM;;CAE/D,MAAM,CAAC,MAAM,SAAS;AACtB,QAAO,YAAY,MAAM,MAAM;;;;;;;;;ACrDnC,SAAgB,IAAU,UAA2D;AACjF,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,IAAI,SAAS,GAAI,UAAS,GAAG,OAAO,MAAM;AAC3D,MAAI,OAAO,OAAO,IAAI,SAAS,IAAK,UAAS,IAAI,OAAO,MAAM;AAC9D,SAAO;;;;;;;;;;ACHf,SAAgB,OAAa,WAAgC,SAAkB;AAC3E,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,EAAE;AACf,OAAI,UAAU,OAAO,MAAM,CACvB,QAAO;AAEX,UAAO,IAAI,SAAS,CAAC;;AAEzB,SAAO;;;;;;;;;;ACRf,SAAgB,MAAe,UAAmD;AAC9E,SAAQ,WAA4B;AAChC,MAAI,OAAO,MAAM,CACb,QAAO,SAAS,GAAG,OAAO,MAAM;AAEpC,MAAI,OAAO,OAAO,CAAE,QAAO,SAAS,IAAI,OAAO,MAAM;AACrD,QAAM,IAAI,wBAAwB,QAAQ;;;;;;;;;;ACLlD,SAAgB,QAAiB,cAAiB;AAC9C,SAAQ,WAA+C;AACnD,MAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,MAAI,OAAO,OAAO,CAAE,QAAO,GAAG,aAAa;AAC3C,QAAM,IAAI,wBAAwB,UAAU;;;;;;AAOpD,SAAgB,YAAqB,IAAqB;AACtD,SAAQ,WAA+C;AACnD,MAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,MAAI,OAAO,OAAO,CAAE,QAAO,GAAG,GAAG,OAAO,MAAM,CAAC;AAC/C,QAAM,IAAI,wBAAwB,cAAc;;;;;;;;;;ACfxD,SAAgB,KAAW,QAAoC;AAC3D,KAAI,OAAO,MAAM,CACb,QAAO,IAAU,OAAO,MAAM;AAElC,KAAI,OAAO,OAAO,CACd,QAAO,GAAS,OAAO,MAAM;AAEjC,OAAM,IAAI,wBAAwB,OAAO;;;;;;;;;;ACP7C,SAAgB,SAAyB,IAAa,aAAqC;AACvF,SAAQ,WAA2C;AAC/C,MAAI,OAAO,OAAO,CAAE,QAAO;AAE3B,MAAI;AACA,UAAO,GAAG,IAAI,CAAC;WACV,OAAO;AACZ,UAAO,IAAI,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;;;;ACRrE,SAAgB,OACZ,SACA,aACF;AACE,SAAQ,WAA2C;AAC/C,MAAI,OAAO,OAAO,CACd,QAAO;AAGX,MAAI;AACA,OAAI,OAAO,MAAM,CAAE,QAAO,GAAa,QAAQ,OAAO,MAAM,CAAC;AAC7D,SAAM,IAAI,wBAAwB,SAAS;WACtC,OAAO;AACZ,UAAO,IAAc,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;;;;;;ACR/E,SAAgB,eACZ,SACiE;CACjE,MAAMG,SAA6C,EAAE;AAErD,MAAK,MAAM,UAAU,SAAS;AAC1B,MAAI,OAAO,MAAM,CACb,QAAO,GACH,OAAO,MACV;AAEL,MAAI,OAAO,OAAO,EAAE;AAChB,UAAO,KAAK,OAAO,MAAqC;AACxD;;AAEJ,QAAM,IAAI,wBAAwB,iBAAiB;;AAGvD,QAAO,IAA+D,OAAO;;;;;;;;ACxBjF,SAAgB,SAAkB,SAAmC;AACjE,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,MAAM,CACb,QAAO,GAAG,MAAM,QAAQ,OAAO,MAAM,CAAC;AAE1C,SAAO;;;;;;;;;ACLf,SAAgB,YAAqB,SAAmC;AACpE,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,OAAO,CACd,QAAO,IAAI,MAAM,QAAQ,OAAO,MAAM,CAAC;AAE3C,SAAO;;;;;;;;;ACNf,SAAgB,aAAsB,SAA8C;AAChF,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,MAAM,CACb,QAAO,MAAM,QAAQ,OAAO,MAAM;AAEtC,SAAO;;;;;;;;;ACLf,SAAgB,SAAe,UAA6E;AACxG,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,MAAM,IAAI,SAAS,GAAI,OAAM,SAAS,GAAG,OAAO,MAAM;AACjE,MAAI,OAAO,OAAO,IAAI,SAAS,IAAK,OAAM,SAAS,IAAI,OAAO,MAAM;AACpE,SAAO;;;;;;;;;ACHf,SAAgB,YAAkB,WAAyC,SAA2B;AAClG,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,MAAM,EAAE;AACf,OAAI,MAAM,UAAU,OAAO,MAAM,CAC7B,QAAO;AAEX,UAAO,IAAI,MAAM,SAAS,CAAC;;AAE/B,SAAO;;;;;;;;;ACRf,SAAgB,WAAoB,UAAqE;AACrG,QAAO,OAAO,WAAqC;AAC/C,MAAI,OAAO,MAAM,CACb,QAAO,MAAM,SAAS,GAAG,OAAO,MAAM;AAE1C,MAAI,OAAO,OAAO,CAAE,QAAO,MAAM,SAAS,IAAI,OAAO,MAAM;AAC3D,QAAM,IAAI,wBAAwB,aAAa;;;;;;;;;ACNvD,SAAgB,cACZ,IACA,aACF;AACE,QAAO,OAAO,WAAoD;AAC9D,MAAI,OAAO,OAAO,CAAE,QAAO;AAE3B,MAAI;AACA,UAAO,GAAG,MAAM,IAAI,CAAC;WAChB,OAAO;AACZ,UAAO,IAAI,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;;;;ACTrE,SAAgB,YACZ,SACA,aACF;AACE,QAAO,OAAO,WAAoD;AAC9D,MAAI,OAAO,OAAO,CACd,QAAO;AAGX,MAAI;AACA,OAAI,OAAO,MAAM,CAAE,QAAO,GAAa,MAAM,QAAQ,OAAO,MAAM,CAAC;AACnE,SAAM,IAAI,wBAAwB,cAAc;WAC3C,OAAO;AACZ,UAAO,IAAc,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;ACuB/E,IAAe,aAAf,cAAkC,SAAS;CAMvC,OAAiD;AAC7C,SAAO,KAAK,SAAS;;CAGzB,QAAmD;AAC/C,SAAO,KAAK,SAAS;;CAGzB,SAAmC,cAAoB;AACnD,SAAO,KAAK,SAAS,OAAO,KAAK,QAAQ;;;;;CAM7C,KAA4C,MAAwB,OAAkC;AAClG,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK,KAAK,MAAM;AAC/C,MAAI,KAAK,SAAS,MAAO,QAAO,MAAM,KAAK,MAAM;AACjD,QAAM,IAAI,wBAAwB,cAAc;;;;;;;;;CAUpD,EAAE,OAAO,YAAwD;AAC7D,SAAQ,MAAM;;;;;;;;CASlB,QAA6D;AACzD,MAAI,KAAK,SAAS,MAAO,QAAO,IAAI,kBAAkB,KAAK,MAAM;AACjE,QAAM,IAAI,gBAAgB;;;;;;;CAQ9B,WAAwE;EACpE,MAAM,WAAqB,UAAoB,IAAqB,MAAM;AAC1E,SAAO,gBAAgB,WAAW,MAAM,QAAQ;;;;;;CAOpD,YAAiF;AAC7E,MAAI,KAAK,SAAS,KAAM,QAAO;GAAE,WAAW;GAAM,MAAM,KAAK;GAAO;AACpE,SAAO;GAAE,WAAW;GAAO,OAAO,KAAK;GAAO;;;;;;CAOlD,iBAA2F;AACvF,MAAI,KAAK,SAAS,KAAM,QAAO;GAAE,WAAW;GAAM,MAAM,KAAK;GAAO;EAEpE,MAAM,QAAQ,KAAK;AAInB,SAAO;GAAE,WAAW;GAAO,OAFvB,SAAS,OAAO,UAAU,YAAY,aAAa,QAAS,MAAc,UAAU,OAAO,MAAM;GAErD;;;AAIxD,IAAa,KAAb,cAAsC,WAAW;CAC7C,AAAS,OAAO;CAChB,AAAS;CACT,AAAS,QAAQ;CAEjB,YAAY,OAAU;AAClB,SAAO;AACP,OAAK,QAAQ;AACb,SAAO,OAAO,KAAK;;;AAI3B,IAAa,MAAb,cAA+C,WAAW;CACtD,AAAS,OAAO;CAChB,AAAS,QAAQ;CACjB,AAAS;CAET,YAAY,OAAU;AAClB,SAAO;AACP,OAAK,QAAQ;AACb,SAAO,OAAO,KAAK;;;AAM3B,SAAgB,GAAiB,OAAyB;AACtD,QAAO,IAAI,GAAS,MAAW;;AAGnC,SAAgB,IAAkB,OAAwB;AACtD,QAAO,IAAI,IAAU,MAAM;;AAG/B,SAAgB,KAAW,WAAoB,SAAY,UAA2B;AAClF,QAAO,YAAY,GAAS,QAAQ,GAAG,IAAU,SAAS;;AAG9D,SAAgB,SAAe,WAAoB,MAAe,OAA8B;AAC5F,QAAO,YAAY,GAAS,MAAM,CAAC,GAAG,IAAU,OAAO,CAAC;;AAG5D,SAAgB,aAAmB,OAAU,OAAqC;AAC9E,KAAI,UAAU,QAAQ,UAAU,OAC5B,QAAO,IAAuB,MAAM;AAExC,QAAO,GAAsB,MAAwB;;AAKzD,eAAsB,YAAkB,SAAqB,aAA4D;AACrH,KAAI;AAEA,SAAO,GADO,MAAM,QACJ;UACX,OAAO;AACZ,MAAI;AACA,UAAO,IAAI,cAAc,YAAY,MAAM,GAAI,MAAY;WACtD,aAAa;AAClB,UAAO,IAAI,YAAiB;;;;AAKxC,SAAgB,MAAS,IAAiC;AACtD,KAAI;AACA,SAAO,GAAG,IAAI,CAAC;UACV,OAAO;AACZ,SAAO,IAAI,MAAM;;;AAIzB,MAAa,SAAS;CAClB;CACA;CACA;CACA;CACA,KAAK;CACR;;;;;;;;ACtMD,SAAgB,SAAS,OAA2C;AAChE,QACI,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,OAAQ,MAA6B,SAAS,cAC9C,WAAW,SACX,OAAQ,MAA8B,UAAU;;;;;ACqBxD,eAAsB,KAClB,eACA,SAC0E;CAC1E,MAAM,WAAW,eAAe;CAChC,IAAIC,QAAiB;AAErB,QAAO,MAAM;EACT,IAAIC;AACJ,MAAI;AACA,UAAO,MAAM,SAAS,KAAK,MAAM;WAC5B,QAAQ;AACb,OAAI,CAAC,QAAS,OAAM;AACpB,UAAO,IAA+D,QAAQ,OAAO,CAAC;;AAG1F,MAAI,KAAK,KACL,KAAI;GACA,MAAM,UAAU,MAAM,KAAK;AAC3B,OAAI,SAAS,QAAQ,CACjB,QAAO;AAEX,UAAO,GAA8D,QAAyB;WACzF,QAAQ;AACb,OAAI,CAAC,QAAS,OAAM;AACpB,UAAO,IAA+D,QAAQ,OAAO,CAAC;;EAI9F,MAAM,UAAU,KAAK;AACrB,MAAI,CAAC,SAAS,QAAQ,CAClB,OAAM,IAAI,wBAAwB,QAAQ;AAG9C,MAAI,QAAQ,MAAM,EAAE;AAChB,WAAQ,QAAQ;AAChB;;AAGJ,MAAI,QAAQ,OAAO,EAAE;AACjB,OAAI;AACA,QAAI,OAAO,SAAS,WAAW,WAC3B,OAAM,SAAS,OAAO,OAA0B;YAE/C,QAAQ;AACb,QAAI,CAAC,QAAS,OAAM;AACpB,WAAO,IAA+D,QAAQ,OAAO,CAAC;;AAG1F,UAAO;;AAGX,QAAM,IAAI,wBAAwB,OAAO;;;AAIjD,MAAa,MAAM;;;;;;;;;;ACjFnB,SAAgB,KAAc,UAAmD;AAC7E,SAAQ,WAA4B;AAChC,MAAI,OAAO,MAAM,CACb,QAAO,SAAS,GAAG,OAAO,MAAM;AAEpC,MAAI,OAAO,OAAO,CAAE,QAAO,SAAS,IAAI,OAAO,MAAM;AACrD,QAAM,IAAI,wBAAwB,OAAO;;;;;;;;;;;;ACNjD,SAAgB,UAAmB,UAAqE;AACpG,QAAO,OAAO,WAAqC;AAC/C,MAAI,OAAO,MAAM,CACb,QAAO,MAAM,SAAS,GAAG,OAAO,MAAM;AAE1C,MAAI,OAAO,OAAO,CAAE,QAAO,MAAM,SAAS,IAAI,OAAO,MAAM;AAC3D,QAAM,IAAI,wBAAwB,YAAY;;;;;;;;;;ACRtD,SAAgB,OAAa,QAAyB;AAClD,KAAI,OAAO,MAAM,CACb,QAAO,OAAO;AAElB,KAAI,OAAO,OAAO,CAAE,OAAM,IAAI,iBAAiB,OAAO,MAAM;AAC5D,OAAM,IAAI,wBAAwB,SAAS;;;;;;;;;ACN/C,SAAgB,SAAe,QAAsB,cAAoB;AACrE,KAAI,OAAO,MAAM,CAAE,QAAO,OAAO;AACjC,QAAO;;;;;;;;;ACDX,SAAgB,aAAmB,QAAsB,IAAwB;AAC7E,KAAI,OAAO,MAAM,CAAE,QAAO,OAAO;AACjC,KAAI,OAAO,OAAO,CAAE,QAAO,GAAG,OAAO,MAAM;AAC3C,OAAM,IAAI,wBAAwB,eAAe;;;;;;;;;ACHrD,SAAgB,gBAAsB,QAAsB,cAAoB;AAC5E,QAAO,SAAS,QAAQ,aAAa;;;;;;;;;ACDzC,SAAgB,cAAoB,QAAyB;AACzD,KAAI,OAAO,MAAM,CAAE,QAAO,OAAO;AACjC,KAAI,OAAO,OAAO,CAAE,OAAM,OAAO;AACjC,OAAM,IAAI,wBAAwB,gBAAgB;;;;;;;;;ACHtD,SAAgB,UAAgB,QAAyB;AACrD,KAAI,OAAO,OAAO,CACd,QAAO,OAAO;AAElB,KAAI,OAAO,MAAM,CAAE,OAAM,IAAI,mBAAmB,OAAO,MAAM;AAC7D,OAAM,IAAI,wBAAwB,YAAY;;;;;;;;;ACLlD,SAAgB,aAAmB,QAAsB,SAAoB;AACzE,KAAI,OAAO,MAAM,CACb,QAAO,OAAO;AAElB,OAAM,IAAI,cAAc,QAAQ;;;;;;;;;ACJpC,SAAgB,UAAgB,QAAsB,SAAoB;AACtE,KAAI,OAAO,OAAO,CACd,QAAO,OAAO;AAElB,OAAM,IAAI,eAAe,QAAQ;;;;;;;;;ACLrC,SAAgB,IAAa,QAAsB,OAAmC;AAClF,QAAO,OAAO,MAAM,GAAG,QAAQ;;;;;;;;;ACDnC,SAAgB,GAAY,QAAsB,OAAmC;AACjF,QAAO,OAAO,MAAM,GAAG,SAAoC;;;;;;;;;ACA/D,SAAgB,OAAgB,QAAsB,IAA8C;AAChG,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO,GAAG,OAAO,MAAM;AAC3C,OAAM,IAAI,wBAAwB,SAAS;;;;;;;;;ACJ/C,SAAgB,MAAe,QAAsB,cAAiB,IAAwB;AAC1F,KAAI,OAAO,MAAM,CAAE,QAAO,GAAG,OAAO,MAAM;AAC1C,QAAO;;;;;;;;;ACDX,SAAgB,UAAmB,QAAsB,WAA4B,IAAwB;AACzG,KAAI,OAAO,MAAM,CAAE,QAAO,GAAG,OAAO,MAAM;AAC1C,KAAI,OAAO,OAAO,CAAE,QAAO,UAAU,OAAO,MAAM;AAClD,OAAM,IAAI,wBAAwB,YAAY;;;;;;;;;;ACDlD,SAAgB,SAAe,SAAkD;CAC7E,MAAMC,SAAc,EAAE;AAEtB,MAAK,MAAM,UAAU,SAAS;AAC1B,MAAI,OAAO,MAAM,EAAE;AACf,UAAO,KAAK,OAAO,MAAM;AACzB;;AAEJ,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAI,wBAAwB,WAAW;;AAGjD,QAAO,GAAG,OAAO;;;;;AAMrB,SAAgB,IAAU,SAAkD;AACxE,QAAO,SAAS,QAAQ;;;;;;;;;ACjB5B,SAAgB,eACZ,QACmE;CAInE,MAAMC,MAAoB,EAAE;AAE5B,MAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAoB;EACrD,MAAM,SAAS,OAAO;AACtB,MAAI,CAAC,OAAQ;AACb,MAAI,OAAO,MAAM,EAAE;AACf,OAAI,OAAO,OAAO;AAClB;;AAEJ,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAI,wBAAwB,iBAAiB;;AAGvD,QAAO,GAAW,IAAW;;;;;;;;;;;;ACVjC,eAAsB,oBAClB,QACkF;CAClF,MAAMC,SAAiD,EAAE;AAEzD,MAAK,MAAM,SAAS,OAChB,KAAI;EACA,MAAM,SAAS,OAAO,OAAO,UAAU,aAAa,OAAO,GAAG;AAC9D,MAAI,OAAO,MAAM,CACb,QAAO,GACH,OAAO,MACV;AAEL,MAAI,OAAO,OAAO,EAAE;AAChB,UAAO,KAAK,OAAO,MAAyC;AAC5D;;AAEJ,QAAM,IAAI,wBAAwB,sBAAsB;UACnD,OAAO;AAEZ,SAAO,KAAK,MAAyC;;AAI7D,QAAO,IAAuE,OAAO;;;;;;;;;;;;;;;;ACtBzF,eAAsB,4BAClB,QACkF;AAIlF,KAAI,OAAO,WAAW,EAClB,QAAO,IAAyB,EAAE,CAAC;CAGvC,MAAM,UAAU,OAAO,KAAK,UACxB,OAAO,UAAU,aAAa,QAAQ,SAAS,CAAC,KAAK,MAAM,GAAG,MACjE;CAED,MAAM,UAAU,IAAI,SAAsC,YAAY;AAClE,OAAK,MAAM,WAAW,QAClB,SACK,MAAM,WAAW;AACd,OAAI,OAAO,MAAM,CACb,SAAQ,GAAwB,OAAO,MAAiB,CAAC;IAE/D,CACD,YAAY,GAEX;GAEZ;CAEF,MAAM,YAAY,QAAQ,WAAW,QAAQ,CAAC,MAAM,YAAY;EAC5D,MAAMC,SAAqB,EAAE;AAC7B,OAAK,MAAM,SAAS,QAChB,KAAI,MAAM,WAAW,aAAa;GAC9B,MAAM,SAAS,MAAM;AACrB,OAAI,OAAO,OAAO,CACd,QAAO,KAAK,OAAO,MAAkB;YAC9B,CAAC,OAAO,MAAM,CACrB,QAAO,KAAK,IAAI,wBAAwB,8BAA8B,CAAa;QAGvF,QAAO,KAAK,MAAM,OAAmB;AAG7C,SAAO,IAAyB,OAAO;GACzC;AAEF,QAAO,QAAQ,KAAK,CAAC,SAAS,UAAU,CAAC;;;;;;;;;AC3D7C,SAAgB,iBAAuB,SAAoD;CACvF,MAAMC,SAAc,EAAE;CACtB,MAAMC,SAAc,EAAE;AAEtB,MAAK,MAAM,UAAU,SAAS;AAC1B,MAAI,OAAO,MAAM,EAAE;AACf,UAAO,KAAK,OAAO,MAAM;AACzB;;AAEJ,MAAI,OAAO,OAAO,EAAE;AAChB,UAAO,KAAK,OAAO,MAAM;AACzB;;AAEJ,QAAM,IAAI,wBAAwB,mBAAmB;;AAGzD,QAAO,OAAO,WAAW,IAAI,GAAG,OAAO,GAAG,IAAc,OAAO;;;;;;;;ACfnE,SAAgB,UACZ,SACkF;CAClF,MAAMC,MAAyC,EAAE;CACjD,MAAMC,OAA2C,EAAE;AAEnD,MAAK,MAAM,UAAU,SAAS;AAC1B,MAAI,OAAO,MAAM,EAAE;AACf,OAAI,KAAK,OAAO,MAAoC;AACpD;;AAEJ,MAAI,OAAO,OAAO,EAAE;AAChB,QAAK,KAAK,OAAO,MAAqC;AACtD;;AAEJ,QAAM,IAAI,wBAAwB,YAAY;;AAGlD,QAAO,CAAC,KAAK,KAAK;;;;;;;;;;ACpBtB,SAAgB,QAAc,QAA+C;AACzE,KAAI,OAAO,MAAM,CACb,QAAO,OAAO;AAElB,QAAO;;;;;;;;;ACJX,SAAgB,UAAgB,QAAkC;AAC9D,KAAI,OAAO,MAAM,CACb,QAAO,QAAQ,QAAQ,OAAO,MAAM;AAExC,KAAI,OAAO,OAAO,CAAE,QAAO,QAAQ,OAAO,OAAO,MAAM;AACvD,OAAM,IAAI,wBAAwB,YAAY;;;;;;;;;ACNlD,SAAgB,WAAiB,QAAgC;AAC7D,KAAI,OAAO,MAAM,CAAE,QAAO,OAAO;AACjC,QAAO;;;;;;;;;ACFX,SAAgB,KAAW,QAA0C;AACjE,QAAO,OAAO,MAAM;;;;;;;;;ACDxB,SAAgB,MAAY,QAA2C;AACnE,QAAO,OAAO,OAAO;;;;;;;;;ACDzB,SAAgB,SAAe,QAAsB,OAAmB;AACpE,KAAI,CAAC,OAAO,MAAM,CAAE,QAAO;AAC3B,QAAO,OAAO,UAAU;;;;;;;;;ACF5B,SAAgB,YAAkB,QAAsB,OAAmB;AACvE,KAAI,CAAC,OAAO,OAAO,CAAE,QAAO;AAC5B,QAAO,OAAO,UAAU"}
+{"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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"}

package/dist/mapOrElse-B0_4r6Jn.mjs

@@ -0,0 +1,96 @@
+import { f as InvalidResultStateError } from "./errors-2WOswg7r.mjs";
+
+//#region src/core/fold.ts
+/**
+* Folds the Result into a single value by applying one of two functions.
+* The end of the pipe.
+*
+* This is the pipe operator equivalent of the `.fold()` instance method.
+*/
+function fold(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new InvalidResultStateError("fold");
+	};
+}
+
+//#endregion
+//#region src/core/foldAsync.ts
+/**
+* Async version of `fold`. Folds the Result into a single value asynchronously.
+* The end of the pipe.
+*
+* This is the async pipe operator equivalent of the `.fold()` instance method.
+*/
+function foldAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new InvalidResultStateError("foldAsync");
+	};
+}
+
+//#endregion
+//#region src/core/and.ts
+/**
+* Combines two Results. Returns the second one only if the first is Ok.
+* Corresponds to Rust `and`.
+*/
+function and(result, other) {
+	if (result.isOk()) return other;
+	if (result.isErr()) return result;
+	throw new InvalidResultStateError("and");
+}
+
+//#endregion
+//#region src/core/or.ts
+/**
+* Fallback to another Result if the first is Err.
+* Corresponds to Rust `or`.
+*/
+function or(result, other) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return other;
+	throw new InvalidResultStateError("or");
+}
+
+//#endregion
+//#region src/core/orElse.ts
+/**
+* Fallback with a function that returns a Result.
+* Corresponds to Rust `or_else`.
+*/
+function orElse(result, fn) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return fn(result.error);
+	throw new InvalidResultStateError("orElse");
+}
+
+//#endregion
+//#region src/core/mapOr.ts
+/**
+* Transforms the value or returns a default value.
+* Corresponds to Rust `map_or`.
+*/
+function mapOr(result, defaultValue, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultValue;
+	throw new InvalidResultStateError("mapOr");
+}
+
+//#endregion
+//#region src/core/mapOrElse.ts
+/**
+* Transforms the value or calculates a default value using a function.
+* Corresponds to Rust `map_or_else`.
+*/
+function mapOrElse(result, defaultFn, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultFn(result.error);
+	throw new InvalidResultStateError("mapOrElse");
+}
+
+//#endregion
+export { and as a, or as i, mapOr as n, foldAsync as o, orElse as r, fold as s, mapOrElse as t };
+//# sourceMappingURL=mapOrElse-B0_4r6Jn.mjs.map

package/dist/mapOrElse-B0_4r6Jn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapOrElse-B0_4r6Jn.mjs","names":[],"sources":["../src/core/fold.ts","../src/core/foldAsync.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts"],"sourcesContent":["import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('fold');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('foldAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines two Results. Returns the second one only if the first is Ok.\n * Corresponds to Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n    if (result.isOk()) return other;\n    if (result.isErr()) return result as unknown as Result<U, E>;\n    throw new InvalidResultStateError('and');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback to another Result if the first is Err.\n * Corresponds to Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return other;\n    throw new InvalidResultStateError('or');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback with a function that returns a Result.\n * Corresponds to Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or returns a default value.\n * Corresponds to Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('mapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or calculates a default value using a function.\n * Corresponds to Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultFn(result.error);\n    throw new InvalidResultStateError('mapOrElse');\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,KAAc,UAAmD;AAC7E,SAAQ,WAA4B;AAChC,MAAI,OAAO,MAAM,CACb,QAAO,SAAS,GAAG,OAAO,MAAM;AAEpC,MAAI,OAAO,OAAO,CAAE,QAAO,SAAS,IAAI,OAAO,MAAM;AACrD,QAAM,IAAI,wBAAwB,OAAO;;;;;;;;;;;;ACNjD,SAAgB,UAAmB,UAAqE;AACpG,QAAO,OAAO,WAAqC;AAC/C,MAAI,OAAO,MAAM,CACb,QAAO,MAAM,SAAS,GAAG,OAAO,MAAM;AAE1C,MAAI,OAAO,OAAO,CAAE,QAAO,MAAM,SAAS,IAAI,OAAO,MAAM;AAC3D,QAAM,IAAI,wBAAwB,YAAY;;;;;;;;;;ACRtD,SAAgB,IAAa,QAAsB,OAAmC;AAClF,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,OAAM,IAAI,wBAAwB,MAAM;;;;;;;;;ACH5C,SAAgB,GAAY,QAAsB,OAAmC;AACjF,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,OAAM,IAAI,wBAAwB,KAAK;;;;;;;;;ACH3C,SAAgB,OAAgB,QAAsB,IAA8C;AAChG,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO,GAAG,OAAO,MAAM;AAC3C,OAAM,IAAI,wBAAwB,SAAS;;;;;;;;;ACH/C,SAAgB,MAAe,QAAsB,cAAiB,IAAwB;AAC1F,KAAI,OAAO,MAAM,CAAE,QAAO,GAAG,OAAO,MAAM;AAC1C,KAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,OAAM,IAAI,wBAAwB,QAAQ;;;;;;;;;ACH9C,SAAgB,UAAmB,QAAsB,WAA4B,IAAwB;AACzG,KAAI,OAAO,MAAM,CAAE,QAAO,GAAG,OAAO,MAAM;AAC1C,KAAI,OAAO,OAAO,CAAE,QAAO,UAAU,OAAO,MAAM;AAClD,OAAM,IAAI,wBAAwB,YAAY"}

package/dist/mapOrElse-B5gx9x2E.d.mts

@@ -0,0 +1,64 @@
+import { s as Result } from "./sequence-C0jlR3AY.mjs";
+
+//#region src/core/fold.d.ts
+
+/**
+ * Folds the Result into a single value by applying one of two functions.
+ * The end of the pipe.
+ *
+ * This is the pipe operator equivalent of the `.fold()` instance method.
+ */
+declare function fold<T, E, R>(handlers: {
+  ok: (val: T) => R;
+  err: (e: E) => R;
+}): (source: Result<T, E>) => R;
+//#endregion
+//#region src/core/foldAsync.d.ts
+/**
+ * Async version of `fold`. Folds the Result into a single value asynchronously.
+ * The end of the pipe.
+ *
+ * This is the async pipe operator equivalent of the `.fold()` instance method.
+ */
+declare function foldAsync<T, E, R>(handlers: {
+  ok: (val: T) => Promise<R>;
+  err: (e: E) => Promise<R>;
+}): (source: Result<T, E>) => Promise<R>;
+//#endregion
+//#region src/core/and.d.ts
+/**
+ * Combines two Results. Returns the second one only if the first is Ok.
+ * Corresponds to Rust `and`.
+ */
+declare function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E>;
+//#endregion
+//#region src/core/or.d.ts
+/**
+ * Fallback to another Result if the first is Err.
+ * Corresponds to Rust `or`.
+ */
+declare function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F>;
+//#endregion
+//#region src/core/orElse.d.ts
+/**
+ * Fallback with a function that returns a Result.
+ * Corresponds to Rust `or_else`.
+ */
+declare function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
+//#endregion
+//#region src/core/mapOr.d.ts
+/**
+ * Transforms the value or returns a default value.
+ * Corresponds to Rust `map_or`.
+ */
+declare function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U;
+//#endregion
+//#region src/core/mapOrElse.d.ts
+/**
+ * Transforms the value or calculates a default value using a function.
+ * Corresponds to Rust `map_or_else`.
+ */
+declare function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U;
+//#endregion
+export { and as a, or as i, mapOr as n, foldAsync as o, orElse as r, fold as s, mapOrElse as t };
+//# sourceMappingURL=mapOrElse-B5gx9x2E.d.mts.map

package/dist/mapOrElse-B5gx9x2E.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapOrElse-B5gx9x2E.d.mts","names":[],"sources":["../src/core/fold.ts","../src/core/foldAsync.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;AAA4E,iBAA5D,IAA4D,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,QAAA,EAAA;EACjD,EAAA,EAAA,CAAA,GAAA,EADyB,CACzB,EAAA,GAD+B,CAC/B;EAAG,GAAA,EAAA,CAAA,CAAA,EADwC,CACxC,EAAA,GAD8C,CAC9C;CAAV,CAAA,EAAA,CAAA,MAAA,EAAA,MAAA,CAAO,CAAP,EAAU,CAAV,CAAA,EAAA,GAAe,CAAf;;;;;AADpB;;;;AAA4E,iBCA5D,SDA4D,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,QAAA,EAAA;EACjD,EAAA,EAAA,CAAA,GAAA,ECD8B,CDC9B,EAAA,GCDoC,ODCpC,CCD4C,CDC5C,CAAA;EAAG,GAAA,EAAA,CAAA,CAAA,ECDsD,CDCtD,EAAA,GCD4D,ODC5D,CCDoE,CDCpE,CAAA;CAAV,CAAA,EAAA,CAAA,MAAA,ECAM,MDAN,CCAa,CDAb,ECAgB,CDAhB,CAAA,EAAA,GCAqB,ODArB,CCA6B,CDA7B,CAAA;;;;;AADpB;;AAA0D,iBEF1C,GFE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EEFrB,MFEqB,CEFd,CFEc,EEFX,CFEW,CAAA,EAAA,KAAA,EEFA,MFEA,CEFO,CFEP,EEFU,CFEV,CAAA,CAAA,EEFe,MFEf,CEFsB,CFEtB,EEFyB,CFEzB,CAAA;;;;;AAA1D;;AAA0D,iBGF1C,EHE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EGFtB,MHEsB,CGFf,CHEe,EGFZ,CHEY,CAAA,EAAA,KAAA,EGFD,MHEC,CGFM,CHEN,EGFS,CHET,CAAA,CAAA,EGFc,MHEd,CGFqB,CHErB,EGFwB,CHExB,CAAA;;;;;AAA1D;;AAA0D,iBIF1C,MJE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EIFlB,MJEkB,CIFX,CJEW,EIFR,CJEQ,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EIFQ,CJER,EAAA,GIFc,MJEd,CIFqB,CJErB,EIFwB,CJExB,CAAA,CAAA,EIF6B,MJE7B,CIFoC,CJEpC,EIFuC,CJEvC,CAAA;;;;;AAA1D;;AAA0D,iBKF1C,KLE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EKFnB,MLEmB,CKFZ,CLEY,EKFT,CLES,CAAA,EAAA,YAAA,EKFS,CLET,EAAA,EAAA,EAAA,CAAA,KAAA,EKFwB,CLExB,EAAA,GKF8B,CLE9B,CAAA,EKFkC,CLElC;;;;;AAA1D;;AAA0D,iBMF1C,SNE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EMFf,MNEe,CMFR,CNEQ,EMFL,CNEK,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EMFkB,CNElB,EAAA,GMFwB,CNExB,EAAA,EAAA,EAAA,CAAA,KAAA,EMFuC,CNEvC,EAAA,GMF6C,CNE7C,CAAA,EMFiD,CNEjD"}

package/dist/mapOrElse-DIe7LkYV.d.cts

@@ -0,0 +1,64 @@
+import { s as Result } from "./sequence-Br6tAIIu.cjs";
+
+//#region src/core/fold.d.ts
+
+/**
+ * Folds the Result into a single value by applying one of two functions.
+ * The end of the pipe.
+ *
+ * This is the pipe operator equivalent of the `.fold()` instance method.
+ */
+declare function fold<T, E, R>(handlers: {
+  ok: (val: T) => R;
+  err: (e: E) => R;
+}): (source: Result<T, E>) => R;
+//#endregion
+//#region src/core/foldAsync.d.ts
+/**
+ * Async version of `fold`. Folds the Result into a single value asynchronously.
+ * The end of the pipe.
+ *
+ * This is the async pipe operator equivalent of the `.fold()` instance method.
+ */
+declare function foldAsync<T, E, R>(handlers: {
+  ok: (val: T) => Promise<R>;
+  err: (e: E) => Promise<R>;
+}): (source: Result<T, E>) => Promise<R>;
+//#endregion
+//#region src/core/and.d.ts
+/**
+ * Combines two Results. Returns the second one only if the first is Ok.
+ * Corresponds to Rust `and`.
+ */
+declare function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E>;
+//#endregion
+//#region src/core/or.d.ts
+/**
+ * Fallback to another Result if the first is Err.
+ * Corresponds to Rust `or`.
+ */
+declare function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F>;
+//#endregion
+//#region src/core/orElse.d.ts
+/**
+ * Fallback with a function that returns a Result.
+ * Corresponds to Rust `or_else`.
+ */
+declare function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
+//#endregion
+//#region src/core/mapOr.d.ts
+/**
+ * Transforms the value or returns a default value.
+ * Corresponds to Rust `map_or`.
+ */
+declare function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U;
+//#endregion
+//#region src/core/mapOrElse.d.ts
+/**
+ * Transforms the value or calculates a default value using a function.
+ * Corresponds to Rust `map_or_else`.
+ */
+declare function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U;
+//#endregion
+export { and as a, or as i, mapOr as n, foldAsync as o, orElse as r, fold as s, mapOrElse as t };
+//# sourceMappingURL=mapOrElse-DIe7LkYV.d.cts.map

package/dist/mapOrElse-DIe7LkYV.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapOrElse-DIe7LkYV.d.cts","names":[],"sources":["../src/core/fold.ts","../src/core/foldAsync.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;AAA4E,iBAA5D,IAA4D,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,QAAA,EAAA;EACjD,EAAA,EAAA,CAAA,GAAA,EADyB,CACzB,EAAA,GAD+B,CAC/B;EAAG,GAAA,EAAA,CAAA,CAAA,EADwC,CACxC,EAAA,GAD8C,CAC9C;CAAV,CAAA,EAAA,CAAA,MAAA,EAAA,MAAA,CAAO,CAAP,EAAU,CAAV,CAAA,EAAA,GAAe,CAAf;;;;;AADpB;;;;AAA4E,iBCA5D,SDA4D,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,QAAA,EAAA;EACjD,EAAA,EAAA,CAAA,GAAA,ECD8B,CDC9B,EAAA,GCDoC,ODCpC,CCD4C,CDC5C,CAAA;EAAG,GAAA,EAAA,CAAA,CAAA,ECDsD,CDCtD,EAAA,GCD4D,ODC5D,CCDoE,CDCpE,CAAA;CAAV,CAAA,EAAA,CAAA,MAAA,ECAM,MDAN,CCAa,CDAb,ECAgB,CDAhB,CAAA,EAAA,GCAqB,ODArB,CCA6B,CDA7B,CAAA;;;;;AADpB;;AAA0D,iBEF1C,GFE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EEFrB,MFEqB,CEFd,CFEc,EEFX,CFEW,CAAA,EAAA,KAAA,EEFA,MFEA,CEFO,CFEP,EEFU,CFEV,CAAA,CAAA,EEFe,MFEf,CEFsB,CFEtB,EEFyB,CFEzB,CAAA;;;;;AAA1D;;AAA0D,iBGF1C,EHE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EGFtB,MHEsB,CGFf,CHEe,EGFZ,CHEY,CAAA,EAAA,KAAA,EGFD,MHEC,CGFM,CHEN,EGFS,CHET,CAAA,CAAA,EGFc,MHEd,CGFqB,CHErB,EGFwB,CHExB,CAAA;;;;;AAA1D;;AAA0D,iBIF1C,MJE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EIFlB,MJEkB,CIFX,CJEW,EIFR,CJEQ,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EIFQ,CJER,EAAA,GIFc,MJEd,CIFqB,CJErB,EIFwB,CJExB,CAAA,CAAA,EIF6B,MJE7B,CIFoC,CJEpC,EIFuC,CJEvC,CAAA;;;;;AAA1D;;AAA0D,iBKF1C,KLE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EKFnB,MLEmB,CKFZ,CLEY,EKFT,CLES,CAAA,EAAA,YAAA,EKFS,CLET,EAAA,EAAA,EAAA,CAAA,KAAA,EKFwB,CLExB,EAAA,GKF8B,CLE9B,CAAA,EKFkC,CLElC;;;;;AAA1D;;AAA0D,iBMF1C,SNE0C,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EMFf,MNEe,CMFR,CNEQ,EMFL,CNEK,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EMFkB,CNElB,EAAA,GMFwB,CNExB,EAAA,EAAA,EAAA,CAAA,KAAA,EMFuC,CNEvC,EAAA,GMF6C,CNE7C,CAAA,EMFiD,CNEjD"}