@shirudo/result 1.0.0 → 1.1.0

package/dist/result-BBOGxvSH.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-BBOGxvSH.cjs","names":["MatchOnOkError","MatchTagMissingHandlerError","InvalidResultStateError","#error","#matched","#value","#handler","#invoke","#memo","MatchErrHandlerNotResultError","#resolved","#resolve","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","UnwrapOnErrError","UnwrapErrOnOkError","ExpectOkError","ExpectErrError","MatchOnOkError"],"sources":["../src/core/pipeable.ts","../src/core/brand.ts","../src/core/isResult.ts","../src/core/matcher.ts","../src/core/sequence.ts","../src/core/zip.ts","../src/core/result.ts"],"sourcesContent":["// AUTO-GENERATED FILE — do not edit by hand.\n// Regenerate with: pnpm generate:pipeable (scripts/generate-pipeable.mjs)\n\nexport 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","export const RESULT_BRAND: unique symbol = Symbol.for('@shirudo/result.brand');\n","import { RESULT_BRAND } from './brand';\nimport type { Result } from './result';\n\ntype ResultLikeObject = {\n    readonly [RESULT_BRAND]?: unknown;\n    readonly _tag?: unknown;\n    readonly isOk?: unknown;\n    readonly isErr?: unknown;\n};\n\nconst hasOwn = (value: object, key: PropertyKey): boolean => Object.prototype.hasOwnProperty.call(value, key);\n\nconst hasResultMethods = (value: ResultLikeObject): boolean => {\n    return typeof value.isOk === 'function' && typeof value.isErr === 'function';\n};\n\nconst hasValidPayload = (value: object & ResultLikeObject): boolean => {\n    if (value._tag === 'Ok') {\n        return hasOwn(value, 'value') && !hasOwn(value, 'error');\n    }\n    if (value._tag === 'Err') {\n        return hasOwn(value, 'error') && !hasOwn(value, 'value');\n    }\n    return false;\n};\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    if (value === null || typeof value !== 'object') return false;\n\n    const candidate = value as object & ResultLikeObject;\n    return candidate[RESULT_BRAND] === true && hasResultMethods(candidate) && hasValidPayload(candidate);\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError } from '../errors';\nimport { isResult } from './isResult';\n\nexport type Ctor<T> = abstract new (...args: any[]) => T;\nexport type TypeGuard<E, A extends E> = (error: E) => error is A;\ntype TaggedBy<K extends PropertyKey, V extends PropertyKey> = { readonly [P in K]: V };\ntype Awaitable<T> = T | Promise<T>;\ntype TagValue<E, K extends keyof E> = Extract<E[K], PropertyKey>;\ntype TagHandlerMap<E, K extends keyof E> = {\n    readonly [V in TagValue<E, K>]: (error: Extract<E, Record<K, V>>) => unknown;\n};\ntype TagHandlerReturn<Handlers> = {\n    [K in keyof Handlers]: Handlers[K] extends (...args: any[]) => infer R ? R : never;\n}[keyof Handlers];\n\nconst matchesTag = <K extends PropertyKey, V extends PropertyKey>(value: unknown, key: K, tag: V): boolean => {\n    return value !== null && typeof value === 'object' && (value as Record<PropertyKey, unknown>)[key] === tag;\n};\n\nexport function matchTag<\n    T,\n    K extends keyof E & PropertyKey,\n    E extends Record<K, PropertyKey>,\n    Handlers extends TagHandlerMap<E, K>,\n>(\n    result: Result<T, E>,\n    key: K,\n    handlers: Handlers\n): TagHandlerReturn<Handlers> {\n    if (result.isOk()) throw new MatchOnOkError('matchTag');\n\n    if (result.isErr()) {\n        const error = result.error;\n        const tag = error[key];\n        // Own-property lookup only: inherited members like Object.prototype.toString\n        // must never be picked up as handlers.\n        const handler = Object.hasOwn(handlers, tag) ? handlers[tag as unknown as keyof Handlers] : undefined;\n\n        if (typeof handler !== 'function') throw new MatchTagMissingHandlerError(tag);\n\n        return (handler as (matchedError: never) => TagHandlerReturn<Handlers>)(error as never);\n    }\n\n    throw new InvalidResultStateError('matchTag');\n}\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<A extends E, R1>(\n        ctor: Ctor<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        if (this.#error instanceof ctor) {\n            return new ErrorMatchBuilder(this.#error, true, handler(this.#error as A)) as unknown as ErrorMatchBuilder<\n                Exclude<E, A>,\n                R | R1\n            >;\n        }\n\n        return this as unknown as ErrorMatchBuilder<Exclude<E, A>, 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    whenTag<K extends PropertyKey, V extends PropertyKey, A extends E = Extract<E, TaggedBy<K, V>>, R1 = never>(\n        key: K,\n        tag: V,\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        if (matchesTag(this.#error, key, tag)) {\n            return new ErrorMatchBuilder(this.#error, true, handler(this.#error as A)) as unknown as ErrorMatchBuilder<\n                Exclude<E, A>,\n                R | R1\n            >;\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\nexport class AsyncErrorMatchBuilder<E, R> {\n    readonly #error: unknown;\n    readonly #matched: boolean;\n    readonly #handler: (() => Awaitable<unknown>) | undefined;\n    // Lazily created on first run()/otherwise() so abandoned chains never\n    // start the handler (and thus can never leak an unhandled rejection).\n    #memo: Promise<unknown> | undefined;\n\n    constructor(error: unknown, matched = false, handler?: () => Awaitable<unknown>) {\n        this.#error = error;\n        this.#matched = matched;\n        this.#handler = handler;\n        Object.freeze(this);\n    }\n\n    when<A extends E, R1>(\n        ctor: Ctor<A>,\n        handler: (error: A) => Awaitable<R1>\n    ): AsyncErrorMatchBuilder<Exclude<E, A>, R | R1> {\n        if (this.#matched) return this as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n\n        if (this.#error instanceof ctor) {\n            const run = (): Awaitable<R1> => handler(this.#error as A);\n            return new AsyncErrorMatchBuilder(this.#error, true, run) as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n        }\n\n        return this as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n    }\n\n    whenGuard<A extends E, R1>(\n        guard: TypeGuard<E, A>,\n        handler: (error: A) => Awaitable<R1>\n    ): AsyncErrorMatchBuilder<Exclude<E, A>, R | R1> {\n        if (this.#matched) return this as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n\n        const error = this.#error as E;\n        if (guard(error)) {\n            const run = (): Awaitable<R1> => handler(error);\n            return new AsyncErrorMatchBuilder(this.#error, true, run) as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n        }\n\n        return this as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n    }\n\n    whenTag<K extends PropertyKey, V extends PropertyKey, A extends E = Extract<E, TaggedBy<K, V>>, R1 = never>(\n        key: K,\n        tag: V,\n        handler: (error: A) => Awaitable<R1>\n    ): AsyncErrorMatchBuilder<Exclude<E, A>, R | R1> {\n        if (this.#matched) return this as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n\n        if (matchesTag(this.#error, key, tag)) {\n            const run = (): Awaitable<R1> => handler(this.#error as A);\n            return new AsyncErrorMatchBuilder(this.#error, true, run) as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n        }\n\n        return this as unknown as AsyncErrorMatchBuilder<Exclude<E, A>, R | R1>;\n    }\n\n    async otherwise<R2>(handler: (error: E) => Awaitable<R2>): Promise<R | R2> {\n        if (this.#matched) return await this.#invoke() as R;\n        return await handler(this.#error as E);\n    }\n\n    async run(this: AsyncErrorMatchBuilder<never, R>): Promise<R> {\n        if (this.#matched) return await this.#invoke() as R;\n        throw this.#error;\n    }\n\n    #invoke(): Promise<unknown> {\n        // Private fields stay writable on frozen instances, so the memo works.\n        this.#memo ??= Promise.resolve().then(this.#handler);\n        return this.#memo;\n    }\n}\n\ntype OkOfResult<R> = R extends Result<infer T, any> ? T : never;\ntype ErrOfResult<R> = R extends Result<any, infer E> ? E : never;\n\nconst expectResultReturn = (value: unknown, handlerName: string): Result<any, any> => {\n    if (isResult(value)) return value;\n    throw new MatchErrHandlerNotResultError(handlerName, value);\n};\n\n/**\n * Matcher for `Result` Errors, which returns a `Result` again.\n *\n * Handlers must return a `Result`.\n * Wrap recovered values with `ok(...)` and mapped errors with `err(...)`.\n */\nexport class ErrMatchBuilder<T, E, OutT, OutE> {\n    readonly #error: unknown;\n    readonly #resolved: Result<any, any> | undefined;\n\n    private constructor(error: unknown, resolved?: Result<any, any>) {\n        this.#error = error;\n        this.#resolved = resolved;\n        Object.freeze(this);\n    }\n\n    static fromResult<T, E>(result: Result<T, E>): ErrMatchBuilder<T, E, never, never> {\n        if (result.isOk()) return new ErrMatchBuilder<T, E, never, never>(undefined, result);\n        if (result.isErr()) return new ErrMatchBuilder<T, E, never, never>(result.error);\n        throw new InvalidResultStateError('ErrMatchBuilder.fromResult');\n    }\n\n    when<A extends E, R1 extends Result<any, any>>(\n        ctor: Ctor<A>,\n        handler: (error: A) => R1\n    ): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>> {\n        if (this.#resolved) {\n            return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n        }\n\n        if (this.#error instanceof ctor) {\n            const out = handler(this.#error as A);\n            const resolved = expectResultReturn(out, 'when');\n            return new ErrMatchBuilder(this.#error, resolved) as unknown as ErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfResult<R1>,\n                OutE | ErrOfResult<R1>\n            >;\n        }\n\n        return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n    }\n\n    whenGuard<A extends E, R1 extends Result<any, any>>(\n        guard: TypeGuard<E, A>,\n        handler: (error: A) => R1\n    ): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>> {\n        if (this.#resolved) return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n\n        const error = this.#error as E;\n        if (guard(error)) {\n            const out = handler(error);\n            const resolved = expectResultReturn(out, 'whenGuard');\n            return new ErrMatchBuilder(this.#error, resolved) as unknown as ErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfResult<R1>,\n                OutE | ErrOfResult<R1>\n            >;\n        }\n\n        return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n    }\n\n    whenTag<K extends PropertyKey, V extends PropertyKey, A extends E = Extract<E, TaggedBy<K, V>>, R1 extends Result<any, any> = never>(\n        key: K,\n        tag: V,\n        handler: (error: A) => R1\n    ): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>> {\n        if (this.#resolved) return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n\n        if (matchesTag(this.#error, key, tag)) {\n            const out = handler(this.#error as A);\n            const resolved = expectResultReturn(out, 'whenTag');\n            return new ErrMatchBuilder(this.#error, resolved) as unknown as ErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfResult<R1>,\n                OutE | ErrOfResult<R1>\n            >;\n        }\n\n        return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n    }\n\n    otherwise<R2 extends Result<any, any>>(handler: (error: E) => R2): Result<T | OutT | OkOfResult<R2>, OutE | ErrOfResult<R2>> {\n        if (this.#resolved) return this.#resolved as Result<T | OutT | OkOfResult<R2>, OutE | ErrOfResult<R2>>;\n\n        const out = handler(this.#error as E);\n        return expectResultReturn(out, 'otherwise') as Result<\n            T | OutT | OkOfResult<R2>,\n            OutE | ErrOfResult<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\nexport class AsyncErrMatchBuilder<T, E, OutT, OutE> {\n    readonly #error: unknown;\n    readonly #resolve: (() => Awaitable<Result<any, any>>) | undefined;\n    // Lazily created on first run()/otherwise() so abandoned chains never\n    // start the handler (and thus can never leak an unhandled rejection).\n    #memo: Promise<Result<any, any>> | undefined;\n\n    private constructor(error: unknown, resolve?: () => Awaitable<Result<any, any>>) {\n        this.#error = error;\n        this.#resolve = resolve;\n        Object.freeze(this);\n    }\n\n    static fromResult<T, E>(result: Result<T, E>): AsyncErrMatchBuilder<T, E, never, never> {\n        if (result.isOk()) return new AsyncErrMatchBuilder<T, E, never, never>(undefined, () => result);\n        if (result.isErr()) return new AsyncErrMatchBuilder<T, E, never, never>(result.error);\n        throw new InvalidResultStateError('AsyncErrMatchBuilder.fromResult');\n    }\n\n    when<A extends E, R1 extends Result<any, any>>(\n        ctor: Ctor<A>,\n        handler: (error: A) => Awaitable<R1>\n    ): AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>> {\n        if (this.#resolve) return this as unknown as AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n\n        if (this.#error instanceof ctor) {\n            const resolve = async (): Promise<Result<any, any>> => expectResultReturn(await handler(this.#error as A), 'when');\n            return new AsyncErrMatchBuilder(this.#error, resolve) as unknown as AsyncErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfResult<R1>,\n                OutE | ErrOfResult<R1>\n            >;\n        }\n\n        return this as unknown as AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n    }\n\n    whenGuard<A extends E, R1 extends Result<any, any>>(\n        guard: TypeGuard<E, A>,\n        handler: (error: A) => Awaitable<R1>\n    ): AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>> {\n        if (this.#resolve) return this as unknown as AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n\n        const error = this.#error as E;\n        if (guard(error)) {\n            const resolve = async (): Promise<Result<any, any>> => expectResultReturn(await handler(error), 'whenGuard');\n            return new AsyncErrMatchBuilder(this.#error, resolve) as unknown as AsyncErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfResult<R1>,\n                OutE | ErrOfResult<R1>\n            >;\n        }\n\n        return this as unknown as AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n    }\n\n    whenTag<K extends PropertyKey, V extends PropertyKey, A extends E = Extract<E, TaggedBy<K, V>>, R1 extends Result<any, any> = never>(\n        key: K,\n        tag: V,\n        handler: (error: A) => Awaitable<R1>\n    ): AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>> {\n        if (this.#resolve) return this as unknown as AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n\n        if (matchesTag(this.#error, key, tag)) {\n            const resolve = async (): Promise<Result<any, any>> => expectResultReturn(await handler(this.#error as A), 'whenTag');\n            return new AsyncErrMatchBuilder(this.#error, resolve) as unknown as AsyncErrMatchBuilder<\n                T,\n                Exclude<E, A>,\n                OutT | OkOfResult<R1>,\n                OutE | ErrOfResult<R1>\n            >;\n        }\n\n        return this as unknown as AsyncErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfResult<R1>, OutE | ErrOfResult<R1>>;\n    }\n\n    async otherwise<R2 extends Result<any, any>>(\n        handler: (error: E) => Awaitable<R2>\n    ): Promise<Result<T | OutT | OkOfResult<R2>, OutE | ErrOfResult<R2>>> {\n        if (this.#resolve) return await this.#invoke() as Result<T | OutT | OkOfResult<R2>, OutE | ErrOfResult<R2>>;\n\n        const out = await handler(this.#error as E);\n        return expectResultReturn(out, 'otherwise') as Result<T | OutT | OkOfResult<R2>, OutE | ErrOfResult<R2>>;\n    }\n\n    async run(this: AsyncErrMatchBuilder<T, never, OutT, OutE>): Promise<Result<T | OutT, OutE>> {\n        if (this.#resolve) return await this.#invoke() as Result<T | OutT, OutE>;\n        throw this.#error;\n    }\n\n    #invoke(): Promise<Result<any, any>> {\n        // Private fields stay writable on frozen instances, so the memo works.\n        this.#memo ??= Promise.resolve().then(this.#resolve);\n        return this.#memo;\n    }\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;\ntype SequenceValues<Results extends readonly Result<any, any>[]> = {\n    -readonly [K in keyof Results]: OkValueOf<Results[K]>;\n};\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<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<SequenceValues<Results>, ErrValueOf<Results[number]>> {\n    const values: Array<OkValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            values.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) return result as unknown as Result<SequenceValues<Results>, ErrValueOf<Results[number]>>;\n        throw new InvalidResultStateError('sequence');\n    }\n\n    return ok<SequenceValues<Results>, ErrValueOf<Results[number]>>(values as SequenceValues<Results>);\n}\n\n/**\n * Alias for `sequence`.\n */\nexport function all<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<SequenceValues<Results>, ErrValueOf<Results[number]>> {\n    return sequence(results);\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    if (!left.isOk() && !left.isErr()) throw new InvalidResultStateError('combine');\n    if (!right.isOk() && !right.isErr()) throw new InvalidResultStateError('combine');\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 { Pipeable } from './pipeable';\nimport { AsyncErrMatchBuilder, AsyncErrorMatchBuilder, ErrMatchBuilder, ErrorMatchBuilder } from './matcher';\nimport { RESULT_BRAND } from './brand';\nimport { isResult } from './isResult';\nimport { all, sequence } from './sequence';\nimport { combine } from './zip';\nimport {\n    ExpectErrError,\n    ExpectOkError,\n    InvalidResultStateError,\n    MatchOnOkError,\n    UnwrapErrOnOkError,\n    UnwrapOnErrError,\n} from '../errors';\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\n    // Basic helpers for internal access in operators\n    isOk<T, E>(this: Result<T, E>): this is Ok<T, E> {\n        if (this._tag === 'Ok') return true;\n        if (this._tag === 'Err') return false;\n        throw new InvalidResultStateError('Result.isOk');\n    }\n\n    isErr<T, E>(this: Result<T, E>): this is Err<T, E> {\n        if (this._tag === 'Err') return true;\n        if (this._tag === 'Ok') return false;\n        throw new InvalidResultStateError('Result.isErr');\n    }\n\n    unwrapOr<T, E>(this: Result<T, E>, defaultValue: T): T {\n        if (this._tag === 'Ok') return this.value;\n        if (this._tag === 'Err') return defaultValue;\n        throw new InvalidResultStateError('Result.unwrapOr');\n    }\n\n    unwrap<T, E>(this: Result<T, E>): T {\n        if (this._tag === 'Ok') return this.value;\n        if (this._tag === 'Err') throw new UnwrapOnErrError(this.error);\n        throw new InvalidResultStateError('Result.unwrap');\n    }\n\n    unwrapErr<T, E>(this: Result<T, E>): E {\n        if (this._tag === 'Err') return this.error;\n        if (this._tag === 'Ok') throw new UnwrapErrOnOkError(this.value);\n        throw new InvalidResultStateError('Result.unwrapErr');\n    }\n\n    unwrapOrElse<T, E>(this: Result<T, E>, fn: (error: E) => T): T {\n        if (this._tag === 'Ok') return this.value;\n        if (this._tag === 'Err') return fn(this.error);\n        throw new InvalidResultStateError('Result.unwrapOrElse');\n    }\n\n    unwrapOrThrow<T, E>(this: Result<T, E>): T {\n        if (this._tag === 'Ok') return this.value;\n        if (this._tag === 'Err') throw this.error;\n        throw new InvalidResultStateError('Result.unwrapOrThrow');\n    }\n\n    expect<T, E>(this: Result<T, E>, message: string): T {\n        if (this._tag === 'Ok') return this.value;\n        if (this._tag === 'Err') throw new ExpectOkError(message, this.error);\n        throw new InvalidResultStateError('Result.expect');\n    }\n\n    expectErr<T, E>(this: Result<T, E>, message: string): E {\n        if (this._tag === 'Err') return this.error;\n        if (this._tag === 'Ok') throw new ExpectErrError(message, this.value);\n        throw new InvalidResultStateError('Result.expectErr');\n    }\n\n    toPromise<T, E>(this: Result<T, E>): Promise<T> {\n        if (this._tag === 'Ok') return Promise.resolve(this.value);\n        if (this._tag === 'Err') return Promise.reject(this.error);\n        throw new InvalidResultStateError('Result.toPromise');\n    }\n\n    toNullable<T, E>(this: Result<T, E>): T | null {\n        if (this._tag === 'Ok') return this.value;\n        if (this._tag === 'Err') return null;\n        throw new InvalidResultStateError('Result.toNullable');\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<this, OkValue<this>, unknown> {\n        return (yield this) as OkValue<this>;\n    }\n\n    matchError<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never> {\n        if (this._tag === 'Err') return new ErrorMatchBuilder(this.error);\n        if (this._tag === 'Ok') throw new MatchOnOkError('matchError');\n        throw new InvalidResultStateError('Result.matchError');\n    }\n\n    matchErrorAsync<T, E>(this: Result<T, E>): AsyncErrorMatchBuilder<E, never> {\n        if (this._tag === 'Err') return new AsyncErrorMatchBuilder(this.error);\n        if (this._tag === 'Ok') throw new MatchOnOkError('matchErrorAsync');\n        throw new InvalidResultStateError('Result.matchErrorAsync');\n    }\n\n    /**\n     * Matches on the **Err** value via a `.when(...)` chain.\n     *\n     * Not the same as the `match({ ok, err })` pipe operator: that operator resolves\n     * **both** branches (Ok and Err) via callbacks, whereas this method is **Err-only**\n     * and returns an {@link ErrorMatchBuilder}.\n     *\n     * Note: for type-safety reasons, `.match()` can only be called on a Result already\n     * narrowed to `Err`, e.g. inside `if (result.isErr()) { ... }`.\n     *\n     * @deprecated Use `.matchError()` for clearer Err-only semantics. For Ok+Err handling,\n     * use the `match({ ok, err })` pipe operator instead.\n     */\n    match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never> {\n        if (this._tag === 'Err') return new ErrorMatchBuilder(this.error);\n        if (this._tag === 'Ok') throw new MatchOnOkError();\n        throw new InvalidResultStateError('Result.match');\n    }\n\n    /**\n     * Matches on the Err value, but normalizes every branch to a `Result`:\n     * - Handlers must return a `Result`\n     * - use `ok(...)` for recovery and `err(...)` for mapped errors\n     */\n    matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never> {\n        return ErrMatchBuilder.fromResult(this);\n    }\n\n    matchErrAsync<T, E>(this: Result<T, E>): AsyncErrMatchBuilder<T, E, never, never> {\n        return AsyncErrMatchBuilder.fromResult(this);\n    }\n\n    /**\n     * Serializes the Result into the discriminated shape\n     * `{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`.\n     *\n     * Unlike {@link serialize}, `Ok(undefined)` stays unambiguous, and the\n     * shape round-trips through `fromSerialized(...)`. It also matches what\n     * `JSON.stringify(result)` produces for a Result instance.\n     */\n    toSerialized<T, E>(this: Result<T, E>): ResultType<T, E> {\n        if (this._tag === 'Ok') return { _tag: 'Ok', value: this.value };\n        if (this._tag === 'Err') return { _tag: 'Err', error: this.error };\n        throw new InvalidResultStateError('Result.toSerialized');\n    }\n\n    /**\n     * Serializes the Result into a simple object format.\n     * Preserves the original types.\n     *\n     * @deprecated Use {@link toSerialized} instead: with this format,\n     * `Ok(undefined)` is indistinguishable from a missing `data` field, and\n     * there is no way to rebuild a Result from it. `toSerialized()`\n     * round-trips via `fromSerialized(...)`.\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        if (this._tag === 'Err') return { isSuccess: false, error: this.error };\n        throw new InvalidResultStateError('Result.serialize');\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        if (this._tag !== 'Err') throw new InvalidResultStateError('Result.toUserFriendly');\n\n        const error = this.error;\n        const errorMessage =\n            error && typeof error === 'object' && 'message' in error\n                ? String((error as { message: unknown }).message)\n                : String(error);\n\n        return { isSuccess: false, error: errorMessage };\n    }\n}\n\n// The brand lives on the shared prototype instead of each instance: a\n// per-instance defineProperty forces a shape transition on every Result\n// construction. isResult() reads the brand through the prototype chain.\nObject.defineProperty(ResultBase.prototype, RESULT_BRAND, {\n    value: true,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n});\n\nexport class Ok<T, E = never> extends ResultBase {\n    readonly _tag = 'Ok' as const;\n    readonly value: T;\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 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        return err(errorMapper ? errorMapper(error) : (error as E));\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 function fromThrowable<const Args extends readonly unknown[], T>(\n    fn: (...args: Args) => T\n): (...args: Args) => Result<T, unknown>;\nexport function fromThrowable<const Args extends readonly unknown[], T, E>(\n    fn: (...args: Args) => T,\n    errorMapper: (error: unknown) => E\n): (...args: Args) => Result<T, E>;\nexport function fromThrowable<const Args extends readonly unknown[], T, E>(\n    fn: (...args: Args) => T,\n    errorMapper?: (error: unknown) => E\n): (...args: Args) => Result<T, E> {\n    return (...args) => {\n        try {\n            return ok<T, E>(fn(...args));\n        } catch (error) {\n            return err<E, T>(errorMapper ? errorMapper(error) : (error as E));\n        }\n    };\n}\n\nexport async function tryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>>;\nexport async function tryAsync<T, E>(fn: () => Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function tryAsync<T, E>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>> {\n    try {\n        return ok<T, E>(await fn());\n    } catch (error) {\n        return err<E, T>(errorMapper ? errorMapper(error) : (error as E));\n    }\n}\n\nexport const Result: {\n    ok: typeof ok;\n    err: typeof err;\n    is: typeof isResult;\n    fromNullable: typeof fromNullable;\n    fromPromise: typeof fromPromise;\n    fromThrowable: typeof fromThrowable;\n    try: typeof tryFn;\n    tryAsync: typeof tryAsync;\n    sequence: typeof sequence;\n    all: typeof all;\n    combine: typeof combine;\n} = {\n    ok,\n    err,\n    is: isResult,\n    fromNullable,\n    fromPromise,\n    fromThrowable,\n    try: tryFn,\n    tryAsync,\n    sequence,\n    all,\n    combine,\n};\n"],"mappings":"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"}