@shirudo/result 0.0.6 → 1.0.0

package/dist/result-CY-KIivk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-CY-KIivk.cjs","names":["ret: any","MatchOnOkError","InvalidResultStateError","#error","#matched","#value","MatchErrHandlerNotResultError","#resolved","values: Array<OkValueOf<Results[number]>>","InvalidResultStateError","InvalidResultStateError","right","left","errors: Array<AE | BE>","InvalidResultStateError","InvalidResultStateError","mapErr","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","errors: Array<ErrValueOf<Results[number]>>","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","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/map.ts","../src/core/mapErr.ts","../src/core/mapBoth.ts","../src/core/flatMap.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"],"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 RESULT_BRAND = 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 } 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        const handler = handlers[tag as unknown as keyof Handlers];\n\n        if (typeof handler !== 'function') throw new InvalidResultStateError('matchTag');\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 #value: Promise<unknown> | undefined;\n\n    constructor(error: unknown, matched = false, value?: Promise<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) => 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 value = Promise.resolve().then(() => handler(this.#error as A));\n            return new AsyncErrorMatchBuilder(this.#error, true, value) 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 value = Promise.resolve().then(() => handler(error));\n            return new AsyncErrorMatchBuilder(this.#error, true, value) 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 value = Promise.resolve().then(() => handler(this.#error as A));\n            return new AsyncErrorMatchBuilder(this.#error, true, value) 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.#value 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.#value as R;\n        throw this.#error;\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 #resolved: Promise<Result<any, any>> | undefined;\n\n    private constructor(error: unknown, resolved?: Promise<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>): AsyncErrMatchBuilder<T, E, never, never> {\n        if (result.isOk()) return new AsyncErrMatchBuilder<T, E, never, never>(undefined, Promise.resolve(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.#resolved) 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 resolved = Promise.resolve().then(() => handler(this.#error as A)).then(out => expectResultReturn(out, 'when'));\n            return new AsyncErrMatchBuilder(this.#error, resolved) 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.#resolved) 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 resolved = Promise.resolve().then(() => handler(error)).then(out => expectResultReturn(out, 'whenGuard'));\n            return new AsyncErrMatchBuilder(this.#error, resolved) 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.#resolved) 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 resolved = Promise.resolve().then(() => handler(this.#error as A)).then(out => expectResultReturn(out, 'whenTag'));\n            return new AsyncErrMatchBuilder(this.#error, resolved) 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.#resolved) return await this.#resolved 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.#resolved) return await this.#resolved as Result<T | OutT, OutE>;\n        throw this.#error;\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 type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\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        if (source.isErr()) return source as unknown as Result<U, E>;\n        throw new InvalidResultStateError('map');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\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        if (source.isOk()) return source as unknown as Result<T, F>;\n        throw new InvalidResultStateError('mapErr');\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';\nimport { InvalidResultStateError } from '../errors';\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, F>(project: (value: T) => Result<U, F>) {\n    return (source: Result<T, E>): Result<U, E | F> => {\n        if (source.isOk()) {\n            return project(source.value);\n        }\n        if (source.isErr()) return source as unknown as Result<U, E | F>;\n        throw new InvalidResultStateError('flatMap');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\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()) {\n            if (observer.ok) observer.ok(source.value);\n            return source;\n        }\n        if (source.isErr()) {\n            if (observer.err) observer.err(source.error);\n            return source;\n        }\n        throw new InvalidResultStateError('tap');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\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        if (source.isErr()) return source;\n        throw new InvalidResultStateError('filter');\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 <SE>(source: Result<unknown, SE>): Result<T, SE | E> => {\n        if (source.isErr()) return source as unknown as Result<T, SE | E>;\n\n        try {\n            return ok<T, SE | E>(fn());\n        } catch (error) {\n            return err<SE | E, T>(errorMapper ? errorMapper(error) : error as E);\n        }\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        if (!source.isOk()) throw new InvalidResultStateError('tryMap');\n\n        try {\n            return ok<U, E | F>(project(source.value));\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';\nimport { InvalidResultStateError } from '../errors';\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        if (source.isErr()) return source as unknown as Result<U, E>;\n        throw new InvalidResultStateError('mapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\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        if (source.isOk()) return source as unknown as Result<T, F>;\n        throw new InvalidResultStateError('mapErrAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of flatMap.\n */\nexport function flatMapAsync<T, E, U, F>(project: (value: T) => Promise<Result<U, F>>) {\n    return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n        if (source.isOk()) {\n            return await project(source.value);\n        }\n        if (source.isErr()) return source as unknown as Result<U, E | F>;\n        throw new InvalidResultStateError('flatMapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\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()) {\n            if (observer.ok) await observer.ok(source.value);\n            return source;\n        }\n        if (source.isErr()) {\n            if (observer.err) await observer.err(source.error);\n            return source;\n        }\n        throw new InvalidResultStateError('tapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\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        if (source.isErr()) return source;\n        throw new InvalidResultStateError('filterAsync');\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 <SE>(source: Result<unknown, SE>): Promise<Result<T, SE | E>> => {\n        if (source.isErr()) return source as unknown as Result<T, SE | E>;\n\n        try {\n            return ok<T, SE | E>(await fn());\n        } catch (error) {\n            return err<SE | E, T>(errorMapper ? errorMapper(error) : error as E);\n        }\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        if (!source.isOk()) throw new InvalidResultStateError('tryMapAsync');\n\n        try {\n            return ok<U, E | F>(await project(source.value));\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\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// 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\n    protected constructor() {\n        super();\n        Object.defineProperty(this, RESULT_BRAND, {\n            value: true,\n            enumerable: false,\n            configurable: false,\n            writable: false,\n        });\n    }\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);\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);\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 `.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     * @deprecated Use `.matchError()` for clearer Err-only semantics.\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 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        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\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, E = unknown>(\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,\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":";;;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,eAAe,OAAO,IAAI,wBAAwB;;;;ACU/D,MAAM,UAAU,OAAe,QAA8B,OAAO,UAAU,eAAe,KAAK,OAAO,IAAI;AAE7G,MAAM,oBAAoB,UAAqC;AAC3D,QAAO,OAAO,MAAM,SAAS,cAAc,OAAO,MAAM,UAAU;;AAGtE,MAAM,mBAAmB,UAA8C;AACnE,KAAI,MAAM,SAAS,KACf,QAAO,OAAO,OAAO,QAAQ,IAAI,CAAC,OAAO,OAAO,QAAQ;AAE5D,KAAI,MAAM,SAAS,MACf,QAAO,OAAO,OAAO,QAAQ,IAAI,CAAC,OAAO,OAAO,QAAQ;AAE5D,QAAO;;;;;;AAOX,SAAgB,SAAS,OAA2C;AAChE,KAAI,UAAU,QAAQ,OAAO,UAAU,SAAU,QAAO;CAExD,MAAM,YAAY;AAClB,QAAO,UAAU,kBAAkB,QAAQ,iBAAiB,UAAU,IAAI,gBAAgB,UAAU;;;;;AClBxG,MAAM,cAA4D,OAAgB,KAAQ,QAAoB;AAC1G,QAAO,UAAU,QAAQ,OAAO,UAAU,YAAa,MAAuC,SAAS;;AAG3G,SAAgB,SAMZ,QACA,KACA,UAC0B;AAC1B,KAAI,OAAO,MAAM,CAAE,OAAM,IAAIC,8BAAe,WAAW;AAEvD,KAAI,OAAO,OAAO,EAAE;EAChB,MAAM,QAAQ,OAAO;EAErB,MAAM,UAAU,SADJ,MAAM;AAGlB,MAAI,OAAO,YAAY,WAAY,OAAM,IAAIC,uCAAwB,WAAW;AAEhF,SAAQ,QAAgE,MAAe;;AAG3F,OAAM,IAAIA,uCAAwB,WAAW;;;;;;;;;AAUjD,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,SACwC;AACxC,MAAI,MAAKD,QAAU,QAAO;AAE1B,MAAI,MAAKD,iBAAkB,KACvB,QAAO,IAAI,kBAAkB,MAAKA,OAAQ,MAAM,QAAQ,MAAKA,MAAY,CAAC;AAM9E,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,QACI,KACA,KACA,SACwC;AACxC,MAAI,MAAKC,QAAU,QAAO;AAE1B,MAAI,WAAW,MAAKD,OAAQ,KAAK,IAAI,CACjC,QAAO,IAAI,kBAAkB,MAAKA,OAAQ,MAAM,QAAQ,MAAKA,MAAY,CAAC;AAM9E,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;;;AAInB,IAAa,yBAAb,MAAa,uBAA6B;CACtC,CAASA;CACT,CAASC;CACT,CAASC;CAET,YAAY,OAAgB,UAAU,OAAO,OAA0B;AACnE,QAAKF,QAAS;AACd,QAAKC,UAAW;AAChB,QAAKC,QAAS;AACd,SAAO,OAAO,KAAK;;CAGvB,KACI,MACA,SAC6C;AAC7C,MAAI,MAAKD,QAAU,QAAO;AAE1B,MAAI,MAAKD,iBAAkB,MAAM;GAC7B,MAAM,QAAQ,QAAQ,SAAS,CAAC,WAAW,QAAQ,MAAKA,MAAY,CAAC;AACrE,UAAO,IAAI,uBAAuB,MAAKA,OAAQ,MAAM,MAAM;;AAG/D,SAAO;;CAGX,UACI,OACA,SAC6C;AAC7C,MAAI,MAAKC,QAAU,QAAO;EAE1B,MAAM,QAAQ,MAAKD;AACnB,MAAI,MAAM,MAAM,EAAE;GACd,MAAM,QAAQ,QAAQ,SAAS,CAAC,WAAW,QAAQ,MAAM,CAAC;AAC1D,UAAO,IAAI,uBAAuB,MAAKA,OAAQ,MAAM,MAAM;;AAG/D,SAAO;;CAGX,QACI,KACA,KACA,SAC6C;AAC7C,MAAI,MAAKC,QAAU,QAAO;AAE1B,MAAI,WAAW,MAAKD,OAAQ,KAAK,IAAI,EAAE;GACnC,MAAM,QAAQ,QAAQ,SAAS,CAAC,WAAW,QAAQ,MAAKA,MAAY,CAAC;AACrE,UAAO,IAAI,uBAAuB,MAAKA,OAAQ,MAAM,MAAM;;AAG/D,SAAO;;CAGX,MAAM,UAAc,SAAuD;AACvE,MAAI,MAAKC,QAAU,QAAO,MAAM,MAAKC;AACrC,SAAO,MAAM,QAAQ,MAAKF,MAAY;;CAG1C,MAAM,MAAwD;AAC1D,MAAI,MAAKC,QAAU,QAAO,MAAM,MAAKC;AACrC,QAAM,MAAKF;;;AAOnB,MAAM,sBAAsB,OAAgB,gBAA0C;AAClF,KAAI,SAAS,MAAM,CAAE,QAAO;AAC5B,OAAM,IAAIG,6CAA8B,aAAa,MAAM;;;;;;;;AAS/D,IAAa,kBAAb,MAAa,gBAAkC;CAC3C,CAASH;CACT,CAASI;CAET,AAAQ,YAAY,OAAgB,UAA6B;AAC7D,QAAKJ,QAAS;AACd,QAAKI,WAAY;AACjB,SAAO,OAAO,KAAK;;CAGvB,OAAO,WAAiB,QAA2D;AAC/E,MAAI,OAAO,MAAM,CAAE,QAAO,IAAI,gBAAoC,QAAW,OAAO;AACpF,MAAI,OAAO,OAAO,CAAE,QAAO,IAAI,gBAAoC,OAAO,MAAM;AAChF,QAAM,IAAIL,uCAAwB,6BAA6B;;CAGnE,KACI,MACA,SACgF;AAChF,MAAI,MAAKK,SACL,QAAO;AAGX,MAAI,MAAKJ,iBAAkB,MAAM;GAE7B,MAAM,WAAW,mBADL,QAAQ,MAAKA,MAAY,EACI,OAAO;AAChD,UAAO,IAAI,gBAAgB,MAAKA,OAAQ,SAAS;;AAQrD,SAAO;;CAGX,UACI,OACA,SACgF;AAChF,MAAI,MAAKI,SAAW,QAAO;EAE3B,MAAM,QAAQ,MAAKJ;AACnB,MAAI,MAAM,MAAM,EAAE;GAEd,MAAM,WAAW,mBADL,QAAQ,MAAM,EACe,YAAY;AACrD,UAAO,IAAI,gBAAgB,MAAKA,OAAQ,SAAS;;AAQrD,SAAO;;CAGX,QACI,KACA,KACA,SACgF;AAChF,MAAI,MAAKI,SAAW,QAAO;AAE3B,MAAI,WAAW,MAAKJ,OAAQ,KAAK,IAAI,EAAE;GAEnC,MAAM,WAAW,mBADL,QAAQ,MAAKA,MAAY,EACI,UAAU;AACnD,UAAO,IAAI,gBAAgB,MAAKA,OAAQ,SAAS;;AAQrD,SAAO;;CAGX,UAAuC,SAAsF;AACzH,MAAI,MAAKI,SAAW,QAAO,MAAKA;AAGhC,SAAO,mBADK,QAAQ,MAAKJ,MAAY,EACN,YAAY;;CAM/C,MAAyE;AACrE,MAAI,MAAKI,SAAW,QAAO,MAAKA;AAChC,QAAM,MAAKJ;;;AAInB,IAAa,uBAAb,MAAa,qBAAuC;CAChD,CAASA;CACT,CAASI;CAET,AAAQ,YAAY,OAAgB,UAAsC;AACtE,QAAKJ,QAAS;AACd,QAAKI,WAAY;AACjB,SAAO,OAAO,KAAK;;CAGvB,OAAO,WAAiB,QAAgE;AACpF,MAAI,OAAO,MAAM,CAAE,QAAO,IAAI,qBAAyC,QAAW,QAAQ,QAAQ,OAAO,CAAC;AAC1G,MAAI,OAAO,OAAO,CAAE,QAAO,IAAI,qBAAyC,OAAO,MAAM;AACrF,QAAM,IAAIL,uCAAwB,kCAAkC;;CAGxE,KACI,MACA,SACqF;AACrF,MAAI,MAAKK,SAAW,QAAO;AAE3B,MAAI,MAAKJ,iBAAkB,MAAM;GAC7B,MAAM,WAAW,QAAQ,SAAS,CAAC,WAAW,QAAQ,MAAKA,MAAY,CAAC,CAAC,MAAK,QAAO,mBAAmB,KAAK,OAAO,CAAC;AACrH,UAAO,IAAI,qBAAqB,MAAKA,OAAQ,SAAS;;AAQ1D,SAAO;;CAGX,UACI,OACA,SACqF;AACrF,MAAI,MAAKI,SAAW,QAAO;EAE3B,MAAM,QAAQ,MAAKJ;AACnB,MAAI,MAAM,MAAM,EAAE;GACd,MAAM,WAAW,QAAQ,SAAS,CAAC,WAAW,QAAQ,MAAM,CAAC,CAAC,MAAK,QAAO,mBAAmB,KAAK,YAAY,CAAC;AAC/G,UAAO,IAAI,qBAAqB,MAAKA,OAAQ,SAAS;;AAQ1D,SAAO;;CAGX,QACI,KACA,KACA,SACqF;AACrF,MAAI,MAAKI,SAAW,QAAO;AAE3B,MAAI,WAAW,MAAKJ,OAAQ,KAAK,IAAI,EAAE;GACnC,MAAM,WAAW,QAAQ,SAAS,CAAC,WAAW,QAAQ,MAAKA,MAAY,CAAC,CAAC,MAAK,QAAO,mBAAmB,KAAK,UAAU,CAAC;AACxH,UAAO,IAAI,qBAAqB,MAAKA,OAAQ,SAAS;;AAQ1D,SAAO;;CAGX,MAAM,UACF,SACkE;AAClE,MAAI,MAAKI,SAAW,QAAO,MAAM,MAAKA;AAGtC,SAAO,mBADK,MAAM,QAAQ,MAAKJ,MAAY,EACZ,YAAY;;CAG/C,MAAM,MAAuF;AACzF,MAAI,MAAKI,SAAW,QAAO,MAAM,MAAKA;AACtC,QAAM,MAAKJ;;;;;;;;;;;AClXnB,SAAgB,SACZ,SAC4D;CAC5D,MAAMK,SAA4C,EAAE;AAEpD,MAAK,MAAM,UAAU,SAAS;AAC1B,MAAI,OAAO,MAAM,EAAE;AACf,UAAO,KAAK,OAAO,MAAoC;AACvD;;AAEJ,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIC,uCAAwB,WAAW;;AAGjD,QAAO,GAAyD,OAAkC;;;;;AAMtG,SAAgB,IACZ,SAC4D;AAC5D,QAAO,SAAS,QAAQ;;;;;AClC5B,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,IAAIC,uCAAwB,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;AACtD,KAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,OAAO,CAAE,OAAM,IAAIH,uCAAwB,UAAU;AAC/E,KAAI,CAAC,MAAM,MAAM,IAAI,CAAC,MAAM,OAAO,CAAE,OAAM,IAAIA,uCAAwB,UAAU;AAEjF,QAAO,IAA4B,OAAO;;AAe9C,SAAgB,QAAQ,GAAG,MAA0B;AACjD,KAAI,KAAK,WAAW,GAAG;EACnB,MAAMC,UAAQ,KAAK;AACnB,UAAQ,WAA2B,YAAYC,QAAMD,QAAM;;CAE/D,MAAM,CAAC,MAAM,SAAS;AACtB,QAAO,YAAY,MAAM,MAAM;;;;;;;;;ACrDnC,SAAgB,IAAa,SAA0B;AACnD,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,CACb,QAAO,GAAG,QAAQ,OAAO,MAAM,CAAC;AAEpC,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIG,uCAAwB,MAAM;;;;;;;;;;ACNhD,SAAgB,OAAgB,SAA0B;AACtD,SAAQ,WAAuC;AAC3C,MAAI,OAAO,OAAO,CACd,QAAO,IAAI,QAAQ,OAAO,MAAM,CAAC;AAErC,MAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,QAAM,IAAIC,uCAAwB,SAAS;;;;;;;;;;ACNnD,SAAgB,QAAoB,OAAwB,UAAyB;AACjF,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,CACb,QAAO,GAAS,MAAM,OAAO,MAAM,CAAC;AAExC,MAAI,OAAO,OAAO,CACd,QAAO,IAAUC,SAAO,OAAO,MAAM,CAAC;AAE1C,QAAM,IAAIC,uCAAwB,UAAU;;;;;;AAOpD,MAAa,QAAQ;;;;;;;;AChBrB,SAAgB,QAAoB,SAAqC;AACrE,SAAQ,WAA2C;AAC/C,MAAI,OAAO,MAAM,CACb,QAAO,QAAQ,OAAO,MAAM;AAEhC,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIC,uCAAwB,UAAU;;;;;;;;;;ACNpD,SAAgB,IAAU,UAA2D;AACjF,SAAQ,WAAuC;AAC3C,MAAI,OAAO,MAAM,EAAE;AACf,OAAI,SAAS,GAAI,UAAS,GAAG,OAAO,MAAM;AAC1C,UAAO;;AAEX,MAAI,OAAO,OAAO,EAAE;AAChB,OAAI,SAAS,IAAK,UAAS,IAAI,OAAO,MAAM;AAC5C,UAAO;;AAEX,QAAM,IAAIC,uCAAwB,MAAM;;;;;;;;;;ACThD,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,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIC,uCAAwB,SAAS;;;;;;;;;;ACVnD,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,IAAIC,uCAAwB,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,IAAIC,uCAAwB,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,IAAIA,uCAAwB,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,IAAIC,uCAAwB,OAAO;;;;;;;;;;ACP7C,SAAgB,SAAyB,IAAa,aAAqC;AACvF,SAAY,WAAmD;AAC3D,MAAI,OAAO,OAAO,CAAE,QAAO;AAE3B,MAAI;AACA,UAAO,GAAc,IAAI,CAAC;WACrB,OAAO;AACZ,UAAO,IAAe,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;;;;ACRhF,SAAgB,OACZ,SACA,aACF;AACE,SAAQ,WAA2C;AAC/C,MAAI,OAAO,OAAO,CACd,QAAO;AAEX,MAAI,CAAC,OAAO,MAAM,CAAE,OAAM,IAAIC,uCAAwB,SAAS;AAE/D,MAAI;AACA,UAAO,GAAa,QAAQ,OAAO,MAAM,CAAC;WACrC,OAAO;AACZ,UAAO,IAAc,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;;;;;;ACR/E,SAAgB,eACZ,SACiE;CACjE,MAAMC,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,IAAIC,uCAAwB,iBAAiB;;AAGvD,QAAO,IAA+D,OAAO;;;;;;;;ACvBjF,SAAgB,SAAkB,SAAmC;AACjE,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,MAAM,CACb,QAAO,GAAG,MAAM,QAAQ,OAAO,MAAM,CAAC;AAE1C,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIC,uCAAwB,WAAW;;;;;;;;;ACNrD,SAAgB,YAAqB,SAAmC;AACpE,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,OAAO,CACd,QAAO,IAAI,MAAM,QAAQ,OAAO,MAAM,CAAC;AAE3C,MAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,QAAM,IAAIC,uCAAwB,cAAc;;;;;;;;;ACPxD,SAAgB,aAAyB,SAA8C;AACnF,QAAO,OAAO,WAAoD;AAC9D,MAAI,OAAO,MAAM,CACb,QAAO,MAAM,QAAQ,OAAO,MAAM;AAEtC,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIC,uCAAwB,eAAe;;;;;;;;;ACNzD,SAAgB,SAAe,UAA6E;AACxG,QAAO,OAAO,WAAgD;AAC1D,MAAI,OAAO,MAAM,EAAE;AACf,OAAI,SAAS,GAAI,OAAM,SAAS,GAAG,OAAO,MAAM;AAChD,UAAO;;AAEX,MAAI,OAAO,OAAO,EAAE;AAChB,OAAI,SAAS,IAAK,OAAM,SAAS,IAAI,OAAO,MAAM;AAClD,UAAO;;AAEX,QAAM,IAAIC,uCAAwB,WAAW;;;;;;;;;ACTrD,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,MAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,QAAM,IAAIC,uCAAwB,cAAc;;;;;;;;;ACVxD,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,IAAIC,uCAAwB,aAAa;;;;;;;;;ACNvD,SAAgB,cACZ,IACA,aACF;AACE,QAAO,OAAW,WAA4D;AAC1E,MAAI,OAAO,OAAO,CAAE,QAAO;AAE3B,MAAI;AACA,UAAO,GAAc,MAAM,IAAI,CAAC;WAC3B,OAAO;AACZ,UAAO,IAAe,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;;;;ACThF,SAAgB,YACZ,SACA,aACF;AACE,QAAO,OAAO,WAAoD;AAC9D,MAAI,OAAO,OAAO,CACd,QAAO;AAEX,MAAI,CAAC,OAAO,MAAM,CAAE,OAAM,IAAIC,uCAAwB,cAAc;AAEpE,MAAI;AACA,UAAO,GAAa,MAAM,QAAQ,OAAO,MAAM,CAAC;WAC3C,OAAO;AACZ,UAAO,IAAc,cAAc,YAAY,MAAM,GAAG,MAAW;;;;;;;ACkC/E,IAAe,aAAf,cAAkC,SAAS;CAGvC,AAAU,cAAc;AACpB,SAAO;AACP,SAAO,eAAe,MAAM,cAAc;GACtC,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;GACb,CAAC;;CAIN,OAAiD;AAC7C,MAAI,KAAK,SAAS,KAAM,QAAO;AAC/B,MAAI,KAAK,SAAS,MAAO,QAAO;AAChC,QAAM,IAAIC,uCAAwB,cAAc;;CAGpD,QAAmD;AAC/C,MAAI,KAAK,SAAS,MAAO,QAAO;AAChC,MAAI,KAAK,SAAS,KAAM,QAAO;AAC/B,QAAM,IAAIA,uCAAwB,eAAe;;CAGrD,SAAmC,cAAoB;AACnD,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,MAAI,KAAK,SAAS,MAAO,QAAO;AAChC,QAAM,IAAIA,uCAAwB,kBAAkB;;CAGxD,SAAoC;AAChC,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,MAAI,KAAK,SAAS,MAAO,OAAM,IAAIC,gCAAiB,KAAK,MAAM;AAC/D,QAAM,IAAID,uCAAwB,gBAAgB;;CAGtD,YAAuC;AACnC,MAAI,KAAK,SAAS,MAAO,QAAO,KAAK;AACrC,MAAI,KAAK,SAAS,KAAM,OAAM,IAAIE,kCAAmB,KAAK,MAAM;AAChE,QAAM,IAAIF,uCAAwB,mBAAmB;;CAGzD,aAAuC,IAAwB;AAC3D,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,MAAI,KAAK,SAAS,MAAO,QAAO,GAAG,KAAK,MAAM;AAC9C,QAAM,IAAIA,uCAAwB,sBAAsB;;CAG5D,gBAA2C;AACvC,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,MAAI,KAAK,SAAS,MAAO,OAAM,KAAK;AACpC,QAAM,IAAIA,uCAAwB,uBAAuB;;CAG7D,OAAiC,SAAoB;AACjD,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,MAAI,KAAK,SAAS,MAAO,OAAM,IAAIG,6BAAc,QAAQ;AACzD,QAAM,IAAIH,uCAAwB,gBAAgB;;CAGtD,UAAoC,SAAoB;AACpD,MAAI,KAAK,SAAS,MAAO,QAAO,KAAK;AACrC,MAAI,KAAK,SAAS,KAAM,OAAM,IAAII,8BAAe,QAAQ;AACzD,QAAM,IAAIJ,uCAAwB,mBAAmB;;CAGzD,YAAgD;AAC5C,MAAI,KAAK,SAAS,KAAM,QAAO,QAAQ,QAAQ,KAAK,MAAM;AAC1D,MAAI,KAAK,SAAS,MAAO,QAAO,QAAQ,OAAO,KAAK,MAAM;AAC1D,QAAM,IAAIA,uCAAwB,mBAAmB;;CAGzD,aAA+C;AAC3C,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK;AACpC,MAAI,KAAK,SAAS,MAAO,QAAO;AAChC,QAAM,IAAIA,uCAAwB,oBAAoB;;;;;CAM1D,KAA4C,MAAwB,OAAkC;AAClG,MAAI,KAAK,SAAS,KAAM,QAAO,KAAK,KAAK,MAAM;AAC/C,MAAI,KAAK,SAAS,MAAO,QAAO,MAAM,KAAK,MAAM;AACjD,QAAM,IAAIA,uCAAwB,cAAc;;;;;;;;;CAUpD,EAAE,OAAO,YAAqD;AAC1D,SAAQ,MAAM;;CAGlB,aAAkE;AAC9D,MAAI,KAAK,SAAS,MAAO,QAAO,IAAI,kBAAkB,KAAK,MAAM;AACjE,MAAI,KAAK,SAAS,KAAM,OAAM,IAAIK,8BAAe,aAAa;AAC9D,QAAM,IAAIL,uCAAwB,oBAAoB;;CAG1D,kBAA4E;AACxE,MAAI,KAAK,SAAS,MAAO,QAAO,IAAI,uBAAuB,KAAK,MAAM;AACtE,MAAI,KAAK,SAAS,KAAM,OAAM,IAAIK,8BAAe,kBAAkB;AACnE,QAAM,IAAIL,uCAAwB,yBAAyB;;;;;;;;;;CAW/D,QAA6D;AACzD,MAAI,KAAK,SAAS,MAAO,QAAO,IAAI,kBAAkB,KAAK,MAAM;AACjE,MAAI,KAAK,SAAS,KAAM,OAAM,IAAIK,+BAAgB;AAClD,QAAM,IAAIL,uCAAwB,eAAe;;;;;;;CAQrD,WAAwE;AACpE,SAAO,gBAAgB,WAAW,KAAK;;CAG3C,gBAAkF;AAC9E,SAAO,qBAAqB,WAAW,KAAK;;;;;;CAOhD,YAAiF;AAC7E,MAAI,KAAK,SAAS,KAAM,QAAO;GAAE,WAAW;GAAM,MAAM,KAAK;GAAO;AACpE,MAAI,KAAK,SAAS,MAAO,QAAO;GAAE,WAAW;GAAO,OAAO,KAAK;GAAO;AACvE,QAAM,IAAIA,uCAAwB,mBAAmB;;;;;;CAOzD,iBAA2F;AACvF,MAAI,KAAK,SAAS,KAAM,QAAO;GAAE,WAAW;GAAM,MAAM,KAAK;GAAO;AACpE,MAAI,KAAK,SAAS,MAAO,OAAM,IAAIA,uCAAwB,wBAAwB;EAEnF,MAAM,QAAQ,KAAK;AAMnB,SAAO;GAAE,WAAW;GAAO,OAJvB,SAAS,OAAO,UAAU,YAAY,aAAa,QAC7C,OAAQ,MAA+B,QAAQ,GAC/C,OAAO,MAAM;GAEyB;;;AAIxD,IAAa,KAAb,cAAsC,WAAW;CAC7C,AAAS,OAAO;CAChB,AAAS;CAET,YAAY,OAAU;AAClB,SAAO;AACP,OAAK,QAAQ;AACb,SAAO,OAAO,KAAK;;;AAI3B,IAAa,MAAb,cAA+C,WAAW;CACtD,AAAS,OAAO;CAChB,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,SAAO,IAAI,cAAc,YAAY,MAAM,GAAI,MAAY;;;AAInE,SAAgB,MAAS,IAAiC;AACtD,KAAI;AACA,SAAO,GAAG,IAAI,CAAC;UACV,OAAO;AACZ,SAAO,IAAI,MAAM;;;AAIzB,SAAgB,cACZ,IACA,aAC+B;AAC/B,SAAQ,GAAG,SAAS;AAChB,MAAI;AACA,UAAO,GAAS,GAAG,GAAG,KAAK,CAAC;WACvB,OAAO;AACZ,UAAO,IAAU,cAAc,YAAY,MAAM,GAAI,MAAY;;;;AAO7E,eAAsB,SAAe,IAAsB,aAA4D;AACnH,KAAI;AACA,SAAO,GAAS,MAAM,IAAI,CAAC;UACtB,OAAO;AACZ,SAAO,IAAU,cAAc,YAAY,MAAM,GAAI,MAAY;;;AAIzE,MAAa,SAAS;CAClB;CACA;CACA,IAAI;CACJ;CACA;CACA;CACA,KAAK;CACL;CACA;CACA;CACA;CACH"}