@shirudo/result 0.0.4 → 0.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/index.cjs +108 -108
  2. package/dist/index.cjs.map +1 -1
  3. package/dist/index.d.cts +113 -113
  4. package/dist/index.d.mts +113 -113
  5. package/dist/index.mjs +108 -108
  6. package/dist/index.mjs.map +1 -1
  7. package/package.json +2 -2
package/dist/index.cjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.cjs","names":["ret: any","#error","#matched","#value","isResult","#makeErr","#resolved","mapErr","right","left","errors: Array<AE | BE>","errors: Array<ErrValueOf<Results[number]>>","input: unknown","step: IteratorResult<Y, R>","values: T[]","out: Partial<Out>","errors: Array<ErrValueOfInput<Inputs[number]>>","errors: ErrValue[]","values: T[]","errors: E[]","oks: Array<OkValueOf<Results[number]>>","errs: Array<ErrValueOf<Results[number]>>"],"sources":["../src/core/pipeable.ts","../src/errors.ts","../src/core/matcher.ts","../src/core/map.ts","../src/core/mapErr.ts","../src/core/mapBoth.ts","../src/core/flatMap.ts","../src/core/zip.ts","../src/core/tap.ts","../src/core/filter.ts","../src/core/match.ts","../src/core/recover.ts","../src/core/swap.ts","../src/core/tryCatch.ts","../src/core/tryMap.ts","../src/core/collectFirstOk.ts","../src/core/mapAsync.ts","../src/core/mapErrAsync.ts","../src/core/flatMapAsync.ts","../src/core/tapAsync.ts","../src/core/filterAsync.ts","../src/core/matchAsync.ts","../src/core/tryCatchAsync.ts","../src/core/tryMapAsync.ts","../src/core/result.ts","../src/core/isResult.ts","../src/gen.ts","../src/core/fold.ts","../src/core/foldAsync.ts","../src/core/unwrap.ts","../src/core/unwrapOr.ts","../src/core/unwrapOrElse.ts","../src/core/unwrapOrDefault.ts","../src/core/unwrapOrThrow.ts","../src/core/unwrapErr.ts","../src/core/expectResult.ts","../src/core/expectErr.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts","../src/core/sequence.ts","../src/core/sequenceRecord.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts","../src/core/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":["export type UnaryFunction<Input, Output> = (input: Input) => Output;\nexport type Awaitable<T> = T | Promise<T>;\n\nexport abstract class Pipeable {\n // -------------------------------------------------------------------------\n // PIPE (Synchron)\n // -------------------------------------------------------------------------\n\n pipe<A>(this: A): A;\n pipe<A, B>(this: A, ab: UnaryFunction<A, B>): B;\n pipe<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>): C;\n pipe<A, B, C, D>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>): D;\n pipe<A, B, C, D, E>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>\n ): E;\n pipe<A, B, C, D, E, F>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>\n ): F;\n pipe<A, B, C, D, E, F, G>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>\n ): G;\n pipe<A, B, C, D, E, F, G, H>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>\n ): H;\n pipe<A, B, C, D, E, F, G, H, I>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>\n ): I;\n pipe<A, B, C, D, E, F, G, H, I, J>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>\n ): J;\n pipe<A, B, C, D, E, F, G, H, I, J, K>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>\n ): K;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>\n ): L;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>\n ): M;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>\n ): N;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>\n ): O;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>\n ): P;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>\n ): Q;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>\n ): R;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>,\n rs: UnaryFunction<R, S>\n ): S;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>,\n rs: UnaryFunction<R, S>,\n st: UnaryFunction<S, T>\n ): T;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>,\n rs: UnaryFunction<R, S>,\n st: UnaryFunction<S, T>,\n tu: UnaryFunction<T, U>\n ): U;\n\n pipe(this: any, ...ops: Array<UnaryFunction<any, any>>): any {\n let ret: any = this;\n for (const op of ops) {\n ret = op(ret);\n }\n return ret;\n }\n\n // -------------------------------------------------------------------------\n // PIPE ASYNC (Asynchron)\n // -------------------------------------------------------------------------\n\n pipeAsync<A>(this: A): Promise<A>;\n pipeAsync<A, B>(this: A, ab: UnaryFunction<A, B>): Promise<Awaited<B>>;\n pipeAsync<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>): Promise<Awaited<C>>;\n pipeAsync<A, B, C, D>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>\n ): Promise<Awaited<D>>;\n pipeAsync<A, B, C, D, E>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>\n ): Promise<Awaited<E>>;\n pipeAsync<A, B, C, D, E, F>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>\n ): Promise<Awaited<F>>;\n pipeAsync<A, B, C, D, E, F, G>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>\n ): Promise<Awaited<G>>;\n pipeAsync<A, B, C, D, E, F, G, H>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>\n ): Promise<Awaited<H>>;\n pipeAsync<A, B, C, D, E, F, G, H, I>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>\n ): Promise<Awaited<I>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>\n ): Promise<Awaited<J>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>\n ): Promise<Awaited<K>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>\n ): Promise<Awaited<L>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>\n ): Promise<Awaited<M>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>\n ): Promise<Awaited<N>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>\n ): Promise<Awaited<O>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>\n ): Promise<Awaited<P>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>\n ): Promise<Awaited<Q>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>\n ): Promise<Awaited<R>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>,\n rs: UnaryFunction<Awaited<R>, S>\n ): Promise<Awaited<S>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>,\n rs: UnaryFunction<Awaited<R>, S>,\n st: UnaryFunction<Awaited<S>, T>\n ): Promise<Awaited<T>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>,\n rs: UnaryFunction<Awaited<R>, S>,\n st: UnaryFunction<Awaited<S>, T>,\n tu: UnaryFunction<Awaited<T>, U>\n ): Promise<Awaited<U>>;\n\n async pipeAsync(this: any, ...ops: Array<(a: any) => Awaitable<any>>): Promise<any> {\n let ret: any = this;\n for (const op of ops) {\n ret = await op(ret);\n }\n return ret;\n }\n}\n\n","export const ERR_INVALID_STATE = 'ERR_INVALID_STATE' as const;\nexport const ERR_TASK_YIELD_NOT_RESULT = 'ERR_TASK_YIELD_NOT_RESULT' as const;\nexport const ERR_MATCH_ON_OK = 'ERR_MATCH_ON_OK' as const;\nexport const ERR_UNWRAP_ON_ERR = 'ERR_UNWRAP_ON_ERR' as const;\nexport const ERR_UNWRAP_ERR_ON_OK = 'ERR_UNWRAP_ERR_ON_OK' as const;\nexport const ERR_EXPECT_OK = 'ERR_EXPECT_OK' as const;\nexport const ERR_EXPECT_ERR = 'ERR_EXPECT_ERR' as const;\n\nexport type ResultErrorCode =\n | typeof ERR_INVALID_STATE\n | typeof ERR_TASK_YIELD_NOT_RESULT\n | typeof ERR_MATCH_ON_OK\n | typeof ERR_UNWRAP_ON_ERR\n | typeof ERR_UNWRAP_ERR_ON_OK\n | typeof ERR_EXPECT_OK\n | typeof ERR_EXPECT_ERR;\n\nconst formatResultErrorMessage = (code: ResultErrorCode, message: string, context?: string): string => {\n if (context) {\n return `${code}: ${message} (context: ${context})`;\n }\n return `${code}: ${message}`;\n};\n\nexport class ResultError extends Error {\n readonly code: ResultErrorCode;\n readonly context?: string;\n\n constructor(message: string, code: ResultErrorCode, context?: string) {\n super(formatResultErrorMessage(code, message, context));\n this.code = code;\n this.context = context;\n this.name = new.target.name;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n\nexport class ResultTypeError extends TypeError {\n readonly code: ResultErrorCode;\n readonly context?: string;\n\n constructor(message: string, code: ResultErrorCode, context?: string) {\n super(formatResultErrorMessage(code, message, context));\n this.code = code;\n this.context = context;\n this.name = new.target.name;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n\nconst INVALID_RESULT_STATE_MESSAGE = 'Unreachable: Result is neither Ok nor Err';\n\nexport class InvalidResultStateError extends ResultError {\n constructor(context?: string) {\n super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_STATE, context);\n }\n}\n\nexport class TaskYieldNotResultError extends ResultTypeError {\n readonly yieldedValue: unknown;\n\n constructor(yieldedValue: unknown) {\n super('task() expected yielded values to be Result. Use `yield*` on a Result.', ERR_TASK_YIELD_NOT_RESULT);\n this.yieldedValue = yieldedValue;\n }\n}\n\nexport class MatchOnOkError extends ResultTypeError {\n constructor() {\n super('match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.', ERR_MATCH_ON_OK);\n }\n}\n\nexport class UnwrapOnErrError extends ResultTypeError {\n readonly errorValue: unknown;\n\n constructor(errorValue: unknown) {\n super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);\n this.errorValue = errorValue;\n }\n}\n\nexport class UnwrapErrOnOkError extends ResultTypeError {\n readonly okValue: unknown;\n\n constructor(okValue: unknown) {\n super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);\n this.okValue = okValue;\n }\n}\n\nexport class ExpectOkError extends ResultError {\n readonly expectedMessage: string;\n\n constructor(expectedMessage: string) {\n super(expectedMessage, ERR_EXPECT_OK);\n this.expectedMessage = expectedMessage;\n }\n}\n\nexport class ExpectErrError extends ResultError {\n readonly expectedMessage: string;\n\n constructor(expectedMessage: string) {\n super(expectedMessage, ERR_EXPECT_ERR);\n this.expectedMessage = expectedMessage;\n }\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\nexport type Ctor<T> = abstract new (...args: any[]) => T;\nexport type TypeGuard<E, A extends E> = (error: E) => error is A;\n\n/**\n * Matcher für Err-Values (liefert einen beliebigen Return-Type, z.B. string messages).\n *\n * - `.when(Ctor, handler)` matched via `instanceof`\n * - `.whenGuard(guard, handler)` matched via Type-Guard\n * - `.run()` ist nur erlaubt, wenn alle Error-Cases behandelt wurden (`E` wurde zu `never` reduziert)\n */\nexport class ErrorMatchBuilder<E, R> {\n readonly #error: unknown;\n readonly #matched: boolean;\n readonly #value: unknown;\n\n constructor(error: unknown, matched = false, value?: unknown) {\n this.#error = error;\n this.#matched = matched;\n this.#value = value;\n Object.freeze(this);\n }\n\n when<C extends Ctor<E>, R1>(\n ctor: C,\n handler: (error: InstanceType<C>) => R1\n ): ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1> {\n if (this.#matched) return this as unknown as ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1>;\n\n if (this.#error instanceof ctor) {\n return new ErrorMatchBuilder(this.#error, true, handler(this.#error as InstanceType<C>)) as unknown as ErrorMatchBuilder<\n Exclude<E, InstanceType<C>>,\n R | R1\n >;\n }\n\n return this as unknown as ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1>;\n }\n\n whenGuard<A extends E, R1>(\n guard: TypeGuard<E, A>,\n handler: (error: A) => R1\n ): ErrorMatchBuilder<Exclude<E, A>, R | R1> {\n if (this.#matched) return this as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n\n const error = this.#error as E;\n if (guard(error)) {\n return new ErrorMatchBuilder(this.#error, true, handler(error)) as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n }\n\n return this as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n }\n\n otherwise<R2>(handler: (error: E) => R2): R | R2 {\n if (this.#matched) return this.#value as R;\n return handler(this.#error as E);\n }\n\n run(this: ErrorMatchBuilder<never, R>): R {\n if (this.#matched) return this.#value as R;\n throw this.#error;\n }\n}\n\ntype OkOfReturn<R> = R extends Result<infer T, any> ? T : never;\ntype ErrOfReturn<R> = R extends Result<any, infer E> ? E : R;\n\ntype ErrFactory = <E>(error: E) => Result<never, E>;\n\nfunction isResult(value: unknown): value is Result<any, any> {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'isOk' in value &&\n typeof (value as any).isOk === 'function' &&\n 'isErr' in value &&\n typeof (value as any).isErr === 'function'\n );\n}\n\n/**\n * Matcher für `Result`-Errors, der immer wieder ein `Result` zurückgibt.\n *\n * Handler dürfen:\n * - ein `Result` zurückgeben (wird direkt returned)\n * - einen Error-Wert zurückgeben (wird automatisch zu `Err(error)` gewrappt)\n */\nexport class ErrMatchBuilder<T, E, OutT, OutE> {\n readonly #makeErr: ErrFactory;\n readonly #error: unknown;\n readonly #resolved: Result<any, any> | undefined;\n\n private constructor(makeErr: ErrFactory, error: unknown, resolved?: Result<any, any>) {\n this.#makeErr = makeErr;\n this.#error = error;\n this.#resolved = resolved;\n Object.freeze(this);\n }\n\n static fromResult<T, E>(result: Result<T, E>, makeErr: ErrFactory): ErrMatchBuilder<T, E, never, never> {\n if (result.isOk()) return new ErrMatchBuilder<T, E, never, never>(makeErr, undefined, result);\n if (result.isErr()) return new ErrMatchBuilder<T, E, never, never>(makeErr, result.error);\n throw new InvalidResultStateError('ErrMatchBuilder.fromResult');\n }\n\n when<C extends Ctor<E>, R1>(\n ctor: C,\n handler: (error: InstanceType<C>) => R1\n ): ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>> {\n if (this.#resolved) {\n return this as unknown as ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n }\n\n if (this.#error instanceof ctor) {\n const out = handler(this.#error as InstanceType<C>);\n const resolved = isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R1>);\n return new ErrMatchBuilder(this.#makeErr, this.#error, resolved) as unknown as ErrMatchBuilder<\n T,\n Exclude<E, InstanceType<C>>,\n OutT | OkOfReturn<R1>,\n OutE | ErrOfReturn<R1>\n >;\n }\n\n return this as unknown as ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n }\n\n whenGuard<A extends E, R1>(\n guard: TypeGuard<E, A>,\n handler: (error: A) => R1\n ): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>> {\n if (this.#resolved) return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n\n const error = this.#error as E;\n if (guard(error)) {\n const out = handler(error);\n const resolved = isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R1>);\n return new ErrMatchBuilder(this.#makeErr, this.#error, resolved) as unknown as ErrMatchBuilder<\n T,\n Exclude<E, A>,\n OutT | OkOfReturn<R1>,\n OutE | ErrOfReturn<R1>\n >;\n }\n\n return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n }\n\n otherwise<R2>(handler: (error: E) => R2): Result<T | OutT | OkOfReturn<R2>, OutE | ErrOfReturn<R2>> {\n if (this.#resolved) return this.#resolved as Result<T | OutT | OkOfReturn<R2>, OutE | ErrOfReturn<R2>>;\n\n const out = handler(this.#error as E);\n return (isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R2>)) as Result<\n T | OutT | OkOfReturn<R2>,\n OutE | ErrOfReturn<R2>\n >;\n }\n\n run(this: ErrMatchBuilder<T, never, OutT, OutE>): Result<T | OutT, OutE> {\n if (this.#resolved) return this.#resolved as Result<T | OutT, OutE>;\n throw this.#error;\n }\n}\n","import type { Result } from './result';\nimport { ok } from './result';\n\n/**\n * Transformiert den Wert (Ok-Fall).\n * Entspricht Rust `map`.\n */\nexport function map<T, E, U>(project: (value: T) => U) {\n return (source: Result<T, E>): Result<U, E> => {\n if (source.isOk()) {\n return ok(project(source.value));\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Transformiert den Fehler (Err-Fall).\n * Entspricht Rust `map_err`.\n */\nexport function mapErr<T, E, F>(project: (error: E) => F) {\n return (source: Result<T, E>): Result<T, F> => {\n if (source.isErr()) {\n return err(project(source.error));\n }\n return source as unknown as Result<T, F>;\n };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transformiert sowohl den Ok-Wert als auch den Err-Fehler.\n * Entspricht 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 für `mapBoth`.\n */\nexport const bimap = mapBoth;\n","import type { Result } from './result';\n\n/**\n * Verkettet eine weitere Operation, die ein Result zurückgibt.\n * Entspricht Rust `and_then` oder JS `flatMap`.\n */\nexport function flatMap<T, E, U>(project: (value: T) => Result<U, E>) {\n return (source: Result<T, E>): Result<U, E> => {\n if (source.isOk()) {\n return project(source.value);\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\nimport { err, ok } from './result';\n\nfunction zipImpl<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE> {\n if (left.isErr()) return left as unknown as Result<[A, B], AE | BE>;\n if (right.isErr()) return right as unknown as Result<[A, B], AE | BE>;\n if (left.isOk() && right.isOk()) return ok<[A, B], AE | BE>([left.value, right.value]);\n throw new InvalidResultStateError('zip');\n}\n\n/**\n * Kombiniert zwei Results zu einem Result eines Tupels.\n * Short-circuits beim ersten Err (links vor rechts).\n */\nexport function zip<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE>;\nexport function zip<A, AE, B, BE>(right: Result<B, BE>): (left: Result<A, AE>) => Result<[A, B], AE | BE>;\nexport function zip(...args: unknown[]): unknown {\n if (args.length === 1) {\n const right = args[0] as Result<any, any>;\n return (left: Result<any, any>) => zipImpl(left, right);\n }\n const [left, right] = args as [Result<any, any>, Result<any, any>];\n return zipImpl(left, right);\n}\n\nfunction combineImpl<A, AE, B, BE>(\n left: Result<A, AE>,\n right: Result<B, BE>\n): Result<[A, B], Array<AE | BE>> {\n if (left.isOk() && right.isOk()) {\n return ok<[A, B], Array<AE | BE>>([left.value, right.value]);\n }\n\n const errors: Array<AE | BE> = [];\n if (left.isErr()) errors.push(left.error as AE | BE);\n if (right.isErr()) errors.push(right.error as AE | BE);\n\n return err<Array<AE | BE>, [A, B]>(errors);\n}\n\n/**\n * Kombiniert zwei Results und sammelt Fehler ein.\n * - Ok nur wenn beide Ok sind\n * - Err([errors]) wenn mindestens ein Err ist (links vor rechts)\n */\nexport function combine<A, AE, B, BE>(\n left: Result<A, AE>,\n right: Result<B, BE>\n): Result<[A, B], Array<AE | BE>>;\nexport function combine<A, AE, B, BE>(\n right: Result<B, BE>\n): (left: Result<A, AE>) => Result<[A, B], Array<AE | BE>>;\nexport function combine(...args: unknown[]): unknown {\n if (args.length === 1) {\n const right = args[0] as Result<any, any>;\n return (left: Result<any, any>) => combineImpl(left, right);\n }\n const [left, right] = args as [Result<any, any>, Result<any, any>];\n return combineImpl(left, right);\n}\n","import type { Result } from './result';\n\n/**\n * Führt einen Seiteneffekt aus (Logging, Debugging), ohne das Result zu ändern.\n * Entspricht Rust `inspect` / `inspect_err`.\n */\nexport function tap<T, E>(observer: { ok?: (val: T) => void; err?: (e: E) => void }) {\n return (source: Result<T, E>): Result<T, E> => {\n if (source.isOk() && observer.ok) observer.ok(source.value);\n if (source.isErr() && observer.err) observer.err(source.error);\n return source;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Prüft eine Bedingung. Wenn falsch, wird das Result zu Err.\n * Entspricht Rust `filter` (teilweise).\n */\nexport function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E) {\n return (source: Result<T, E>): Result<T, E> => {\n if (source.isOk()) {\n if (predicate(source.value)) {\n return source;\n }\n return err(errorFn());\n }\n return source;\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Löst das Result auf. Das Ende der Pipe.\n * Entspricht 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: wandelt Err in Ok(defaultValue) um.\n * Ergebnis ist garantiert Ok → Error-Typ wird `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 * Wie `recover`, aber berechnet den Default-Wert anhand des Errors.\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 * Tauscht Ok und 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 * Führt eine Funktion aus und fängt Exceptions ab.\n * Wandelt Exceptions in Result<E> um.\n * Entspricht Rust `Result::from` für fallible Operationen.\n */\nexport function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E) {\n return (source: Result<any, any>): Result<T, E> => {\n if (source.isErr()) return source as unknown as Result<T, E>;\n\n try {\n return ok(fn());\n } catch (error) {\n return err(errorMapper ? errorMapper(error) : error as E);\n }\n };\n}","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Wie `map`, aber fängt Exceptions ab und wandelt sie in Err um.\n */\nexport function tryMap<T, E, U, F = unknown>(\n project: (value: T) => U,\n errorMapper?: (error: unknown) => F\n) {\n return (source: Result<T, E>): Result<U, E | F> => {\n if (source.isErr()) {\n return source as unknown as Result<U, E | F>;\n }\n\n try {\n if (source.isOk()) return ok<U, E | F>(project(source.value));\n throw new InvalidResultStateError('tryMap');\n } catch (error) {\n return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n }\n };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Parse a set of `Result`s, short-circuits when an input value is `Ok`.\n * If no `Ok` is found, returns an `Err` containing the collected error values.\n * Useful for \"try multiple approaches until one works\" patterns.\n */\nexport function collectFirstOk<const Results extends readonly Result<any, any>[]>(\n results: Results\n): Result<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]> {\n const errors: Array<ErrValueOf<Results[number]>> = [];\n\n for (const result of results) {\n if (result.isOk()) {\n return ok<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]>(\n result.value as OkValueOf<Results[number]>\n );\n }\n if (result.isErr()) {\n errors.push(result.error as ErrValueOf<Results[number]>);\n continue;\n }\n throw new InvalidResultStateError('collectFirstOk');\n }\n\n return err<ErrValueOf<Results[number]>[], OkValueOf<Results[number]>>(errors);\n}\n","import type { Result } from './result';\nimport { ok } from './result';\n\n/**\n * Async-Version von map.\n */\nexport function mapAsync<T, E, U>(project: (value: T) => Promise<U>) {\n return async (source: Result<T, E>): Promise<Result<U, E>> => {\n if (source.isOk()) {\n return ok(await project(source.value));\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Async-Version von mapErr.\n */\nexport function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>) {\n return async (source: Result<T, E>): Promise<Result<T, F>> => {\n if (source.isErr()) {\n return err(await project(source.error));\n }\n return source as unknown as Result<T, F>;\n };\n}\n","import type { Result } from './result';\n\n/**\n * Async-Version von flatMap.\n */\nexport function flatMapAsync<T, E, U>(project: (value: T) => Promise<Result<U, E>>) {\n return async (source: Result<T, E>): Promise<Result<U, E>> => {\n if (source.isOk()) {\n return await project(source.value);\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\n\n/**\n * Async-Version von tap.\n */\nexport function tapAsync<T, E>(observer: { ok?: (val: T) => Promise<void>; err?: (e: E) => Promise<void> }) {\n return async (source: Result<T, E>): Promise<Result<T, E>> => {\n if (source.isOk() && observer.ok) await observer.ok(source.value);\n if (source.isErr() && observer.err) await observer.err(source.error);\n return source;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Async-Version von filter.\n */\nexport function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>) {\n return async (source: Result<T, E>): Promise<Result<T, E>> => {\n if (source.isOk()) {\n if (await predicate(source.value)) {\n return source;\n }\n return err(await errorFn());\n }\n return source;\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async-Version von 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 von tryCatch.\n */\nexport function tryCatchAsync<T, E = unknown>(\n fn: () => Promise<T>,\n errorMapper?: (error: unknown) => E\n) {\n return async (source: Result<any, any>): Promise<Result<T, E>> => {\n if (source.isErr()) return source as unknown as Result<T, E>;\n\n try {\n return ok(await fn());\n } catch (error) {\n return err(errorMapper ? errorMapper(error) : error as E);\n }\n };\n}","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async-Version von tryMap.\n */\nexport function tryMapAsync<T, E, U, F = unknown>(\n project: (value: T) => Promise<U>,\n errorMapper?: (error: unknown) => F\n) {\n return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n if (source.isErr()) {\n return source as unknown as Result<U, E | F>;\n }\n\n try {\n if (source.isOk()) return ok<U, E | F>(await project(source.value));\n throw new InvalidResultStateError('tryMapAsync');\n } catch (error) {\n return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n }\n };\n}\n","import { Pipeable } from './pipeable';\nimport { ErrMatchBuilder, ErrorMatchBuilder } from './matcher';\nimport { InvalidResultStateError, MatchOnOkError } from '../errors';\n\n// Re-export pipe operators for convenience\nexport { map } from './map';\nexport { mapErr } from './mapErr';\nexport { bimap, mapBoth } from './mapBoth';\nexport { flatMap } from './flatMap';\nexport { zip, combine } from './zip';\nexport { tap } from './tap';\nexport { filter } from './filter';\nexport { match } from './match';\nexport { recover, recoverWith } from './recover';\nexport { swap } from './swap';\nexport { tryCatch } from './tryCatch';\nexport { tryMap } from './tryMap';\nexport { collectFirstOk } from './collectFirstOk';\n\n// Async variants\nexport { mapAsync } from './mapAsync';\nexport { mapErrAsync } from './mapErrAsync';\nexport { flatMapAsync } from './flatMapAsync';\nexport { tapAsync } from './tapAsync';\nexport { filterAsync } from './filterAsync';\nexport { matchAsync } from './matchAsync';\nexport { tryCatchAsync } from './tryCatchAsync';\nexport { tryMapAsync } from './tryMapAsync';\n\n// --- 1. Hilfstypen ---\n\n// Ein Operator ist eine Funktion, die ein Result nimmt und etwas anderes zurückgibt.\nexport type OperatorFunction<T, E, R> = (input: Result<T, E>) => R;\nexport type { Awaitable } from './pipeable';\nexport type AsyncOperatorFunction<T, E, R> = (input: Result<T, E>) => Promise<R>;\n\n// --- 2. Result Types ---\n\nexport type ResultType<T, E> = { readonly _tag: 'Ok'; readonly value: T } | { readonly _tag: 'Err'; readonly error: E };\n\nexport type Result<T, E> = Ok<T, E> | Err<T, E>;\ntype OkValue<R> = R extends { readonly _tag: 'Ok'; readonly value: infer T } ? T : never;\n\nabstract class ResultBase extends Pipeable {\n abstract readonly _tag: 'Ok' | 'Err';\n abstract readonly value: unknown;\n abstract readonly error: unknown;\n\n // Basic helpers für internen Zugriff in Operatoren\n isOk<T, E>(this: Result<T, E>): this is Ok<T, E> {\n return this._tag === 'Ok';\n }\n\n isErr<T, E>(this: Result<T, E>): this is Err<T, E> {\n return this._tag === 'Err';\n }\n\n unwrapOr<T, E>(this: Result<T, E>, defaultValue: T): T {\n return this._tag === 'Ok' ? this.value : defaultValue;\n }\n\n /**\n * Folds the Result into a single value by applying one of two functions.\n */\n fold<T, E, R1, R2 = R1>(this: Result<T, E>, onOk: (value: T) => R1, onErr: (error: E) => R2): R1 | R2 {\n if (this._tag === 'Ok') return onOk(this.value);\n if (this._tag === 'Err') return onErr(this.error);\n throw new InvalidResultStateError('Result.fold');\n }\n\n /**\n * Enables `yield* result` in generators (Do-notation).\n *\n * The iterator yields the `Result` itself; the runner (see `task`) decides:\n * - Ok → sends back the Ok value (`next(value)`), `yield*` yields `T`\n * - Err → aborts and returns the Err Result\n */\n *[Symbol.iterator](): Generator<unknown, OkValue<this>, unknown> {\n return (yield this) as OkValue<this>;\n }\n\n /**\n * Matcht auf den Err-Wert via `.when(...)` Kette.\n *\n * Hinweis: aus Type-Safety-Gründen ist `.match()` nur auf einem bereits zu `Err` verengten Result aufrufbar,\n * z.B. innerhalb von `if (result.isErr()) { ... }`.\n */\n match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never> {\n if (this._tag === 'Err') return new ErrorMatchBuilder(this.error);\n throw new MatchOnOkError();\n }\n\n /**\n * Matcht auf den Err-Wert, aber normalisiert jeden Branch zu einem `Result`:\n * - Handler dürfen ein `Result` zurückgeben (wird direkt returned)\n * - oder einen Error-Wert (wird zu `Err(error)` gewrappt)\n */\n matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never> {\n const makeErr = <ErrValue>(error: ErrValue) => err<ErrValue, never>(error);\n return ErrMatchBuilder.fromResult(this, makeErr);\n }\n\n /**\n * Serialisiert das Result in ein einfaches Objekt-Format.\n * Behält die ursprünglichen Typen bei.\n */\n serialize<T, E>(this: Result<T, E>): { isSuccess: boolean; data?: T; error?: E } {\n if (this._tag === 'Ok') return { isSuccess: true, data: this.value };\n return { isSuccess: false, error: this.error };\n }\n\n /**\n * Serialisiert das Result in ein user-friendly Format.\n * Konvertiert Errors zu lesbaren Strings.\n */\n toUserFriendly<T, E>(this: Result<T, E>): { isSuccess: boolean; data?: T; error?: string } {\n if (this._tag === 'Ok') return { isSuccess: true, data: this.value };\n\n const error = this.error;\n const errorMessage =\n error && typeof error === 'object' && 'message' in error ? (error as any).message : String(error);\n\n return { isSuccess: false, error: errorMessage };\n }\n}\n\nexport class Ok<T, E = never> extends ResultBase {\n readonly _tag = 'Ok' as const;\n readonly value: T;\n readonly error = undefined;\n\n constructor(value: T) {\n super();\n this.value = value;\n Object.freeze(this);\n }\n}\n\nexport class Err<T = never, E = never> extends ResultBase {\n readonly _tag = 'Err' as const;\n readonly value = undefined;\n readonly error: E;\n\n constructor(error: E) {\n super();\n this.error = error;\n Object.freeze(this);\n }\n}\n\nexport function ok(): Result<void, never>;\nexport function ok<T, E = never>(value: T): Result<T, E>;\nexport function ok<T, E = never>(value?: T): Result<T, E> {\n return new Ok<T, E>(value as T);\n}\n\nexport function err<E, T = never>(error: E): Result<T, E> {\n return new Err<T, E>(error);\n}\n\nexport function okIf<T, E>(condition: boolean, okValue: T, errValue: E): Result<T, E> {\n return condition ? ok<T, E>(okValue) : err<E, T>(errValue);\n}\n\nexport function okIfLazy<T, E>(condition: boolean, okFn: () => T, errFn: () => E): Result<T, E> {\n return condition ? ok<T, E>(okFn()) : err<E, T>(errFn());\n}\n\nexport function fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E> {\n if (value === null || value === undefined) {\n return err<E, NonNullable<T>>(error);\n }\n return ok<NonNullable<T>, E>(value as NonNullable<T>);\n}\n\nexport function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;\nexport function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>> {\n try {\n const value = await promise;\n return ok(value);\n } catch (error) {\n try {\n return err(errorMapper ? errorMapper(error) : (error as E));\n } catch (mapperError) {\n return err(mapperError as E);\n }\n }\n}\n\nexport function tryFn<T>(fn: () => T): Result<T, unknown> {\n try {\n return ok(fn());\n } catch (error) {\n return err(error);\n }\n}\n\nexport const Result = {\n ok,\n err,\n fromNullable,\n fromPromise,\n try: tryFn,\n};\n","import type { Result } from './result';\n\n/**\n * Checks whether a value is a Result.\n * Pure function alternative for runtime checks.\n */\nexport function isResult(value: unknown): value is Result<any, any> {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'isOk' in value &&\n typeof (value as { isOk?: unknown }).isOk === 'function' &&\n 'isErr' in value &&\n typeof (value as { isErr?: unknown }).isErr === 'function'\n );\n}\n","import type { Result } from './core/result';\nimport { err, ok } from './core/result';\nimport { isResult } from './core/isResult';\nimport { InvalidResultStateError, TaskYieldNotResultError } from './errors';\n\ntype AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturn<R> = Awaited<R>;\ntype OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;\ntype ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;\n\n/**\n * Generator-based do-notation for `Result`.\n *\n * Usage:\n * ```ts\n * const out = await task(async function* () {\n * const user = yield* await fromPromise(findUser(1));\n * const email = yield* validate(user.email);\n * return email;\n * });\n * ```\n */\nexport async function task<const Y, const R>(\n makeGenerator: () => AnyGenerator<Y, R, unknown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;\nexport async function task<const Y, const R, EThrown>(\n makeGenerator: () => AnyGenerator<Y, R, unknown>,\n onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;\nexport async function task<const Y, const R, EThrown>(\n makeGenerator: () => AnyGenerator<Y, R, unknown>,\n onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> {\n const iterator = makeGenerator();\n let input: unknown = undefined;\n\n while (true) {\n let step: IteratorResult<Y, R>;\n try {\n step = await iterator.next(input);\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n }\n\n if (step.done) {\n try {\n const awaited = await step.value;\n if (isResult(awaited)) {\n return awaited as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n }\n return ok<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>(awaited as OkOfReturn<R>);\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n }\n }\n\n const yielded = step.value as unknown;\n if (!isResult(yielded)) {\n throw new TaskYieldNotResultError(yielded);\n }\n\n if (yielded.isOk()) {\n input = yielded.value;\n continue;\n }\n\n if (yielded.isErr()) {\n try {\n if (typeof iterator.return === 'function') {\n await iterator.return(undefined as unknown as R);\n }\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n }\n\n return yielded as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n }\n\n throw new InvalidResultStateError('task');\n }\n}\n\nexport const gen = task;\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n return (source: Result<T, E>): R => {\n if (source.isOk()) {\n return handlers.ok(source.value);\n }\n if (source.isErr()) return handlers.err(source.error);\n throw new InvalidResultStateError('fold');\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n return async (source: Result<T, E>): Promise<R> => {\n if (source.isOk()) {\n return await handlers.ok(source.value);\n }\n if (source.isErr()) return await handlers.err(source.error);\n throw new InvalidResultStateError('foldAsync');\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapOnErrError } from '../errors';\n\n/**\n * Gibt den Wert zurück oder wirft einen Error.\n * Entspricht Rust `unwrap`.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n if (result.isOk()) {\n return result.value;\n }\n if (result.isErr()) throw new UnwrapOnErrError(result.error);\n throw new InvalidResultStateError('unwrap');\n}\n","import type { Result } from './result';\n\n/**\n * Gibt den Wert zurück oder einen Default-Wert.\n * Pure function Alternative zur Instanz-Methode.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n if (result.isOk()) return result.value;\n return defaultValue;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Gibt den Wert zurück oder berechnet einen Default-Wert mit einer Funktion.\n * Entspricht Rust `unwrap_or_else`.\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n if (result.isOk()) return result.value;\n if (result.isErr()) return fn(result.error);\n throw new InvalidResultStateError('unwrapOrElse');\n}\n","import type { Result } from './result';\nimport { unwrapOr } from './unwrapOr';\n\n/**\n * Alias für `unwrapOr`.\n * Entspricht Rust `unwrap_or_default` (mit explizitem Default-Wert).\n */\nexport function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T {\n return unwrapOr(result, defaultValue);\n}\n\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Gibt den Wert zurück oder wirft den originalen Err-Wert (nicht gewrappt).\n * Nützlich um `Error`-Instanzen inkl. Stacktrace zu erhalten.\n */\nexport function unwrapOrThrow<T, E>(result: Result<T, E>): T {\n if (result.isOk()) return result.value;\n if (result.isErr()) throw result.error;\n throw new InvalidResultStateError('unwrapOrThrow');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapErrOnOkError } from '../errors';\n\n/**\n * Gibt den Fehler zurück oder wirft einen Error.\n * Entspricht Rust `unwrap_err`.\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n if (result.isErr()) {\n return result.error;\n }\n if (result.isOk()) throw new UnwrapErrOnOkError(result.value);\n throw new InvalidResultStateError('unwrapErr');\n}\n","import type { Result } from './result';\nimport { ExpectOkError } from '../errors';\n\n/**\n * Gibt den Wert zurück oder wirft einen Error mit custom Nachricht.\n * Entspricht Rust `expect`.\n */\nexport function expectResult<T, E>(result: Result<T, E>, message: string): T {\n if (result.isOk()) {\n return result.value;\n }\n throw new ExpectOkError(message);\n}\n","import type { Result } from './result';\nimport { ExpectErrError } from '../errors';\n\n/**\n * Gibt den Fehler zurück oder wirft einen Error mit custom Nachricht.\n * Entspricht Rust `expect_err`.\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n if (result.isErr()) {\n return result.error;\n }\n throw new ExpectErrError(message);\n}\n","import type { Result } from './result';\n\n/**\n * Kombiniert zwei Results. Gibt den zweiten zurück nur wenn erster Ok ist.\n * Entspricht Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n return result.isOk() ? other : result as unknown as Result<U, E>;\n}","import type { Result } from './result';\n\n/**\n * Fallback zu einem anderen Result wenn erster Err ist.\n * Entspricht Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n return result.isOk() ? result as unknown as Result<T, F> : other;\n}","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback mit einer Funktion die ein Result zurückgibt.\n * Entspricht Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n if (result.isOk()) return result as unknown as Result<T, F>;\n if (result.isErr()) return fn(result.error);\n throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\n\n/**\n * Transformiert den Wert oder gibt einen Default-Wert zurück.\n * Entspricht Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n if (result.isOk()) return fn(result.value);\n return defaultValue;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transformiert den Wert oder berechnet einen Default-Wert mit einer Funktion.\n * Entspricht Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n if (result.isOk()) return fn(result.value);\n if (result.isErr()) return defaultFn(result.error);\n throw new InvalidResultStateError('mapOrElse');\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Kombiniert eine Liste von Results zu einem Result einer Liste.\n * Short-circuits beim ersten Err.\n * Analog zu Rust `collect::<Result<Vec<_>, _>>()`.\n */\nexport function sequence<T, E>(results: readonly Result<T, E>[]): Result<T[], E> {\n const values: T[] = [];\n\n for (const result of results) {\n if (result.isOk()) {\n values.push(result.value);\n continue;\n }\n if (result.isErr()) return result as unknown as Result<T[], E>;\n throw new InvalidResultStateError('sequence');\n }\n\n return ok(values);\n}\n\n/**\n * Alias für `sequence`.\n */\nexport function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E> {\n return sequence(results);\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Wie `sequence`, aber für Records/Objekte.\n * Short-circuits beim ersten Err.\n */\nexport function sequenceRecord<const R extends Record<string, Result<any, any>>>(\n record: R\n): Result<{ [K in keyof R]: OkValueOf<R[K]> }, ErrValueOf<R[keyof R]>> {\n type Out = { [K in keyof R]: OkValueOf<R[K]> };\n type E = ErrValueOf<R[keyof R]>;\n\n const out: Partial<Out> = {};\n\n for (const key of Object.keys(record) as Array<keyof R>) {\n const result = record[key];\n if (!result) continue;\n if (result.isOk()) {\n out[key] = result.value as Out[typeof key];\n continue;\n }\n if (result.isErr()) return result as unknown as Result<Out, E>;\n throw new InvalidResultStateError('sequenceRecord');\n }\n\n return ok<Out, E>(out as Out);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport type { Awaitable } from './pipeable';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput =\n | Promise<Result<any, any>>\n | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Async-Version von collectFirstOk.\n *\n * - Nimmt entweder bereits gestartete Promises oder \"Thunks\" (`() => Awaitable<Result<...>>`).\n * - Verarbeitet die Inputs strikt sequentiell (wie `for ... of` + `await`).\n * - Gibt das erste `Ok` zurück und sammelt alle Errors wenn kein `Ok` gefunden wird.\n */\nexport async function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n const errors: Array<ErrValueOfInput<Inputs[number]>> = [];\n\n for (const input of inputs) {\n try {\n const result = await (typeof input === 'function' ? input() : input);\n if (result.isOk()) {\n return ok<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>(\n result.value as OkValueOfInput<Inputs[number]>\n );\n }\n if (result.isErr()) {\n errors.push(result.error as ErrValueOfInput<Inputs[number]>);\n continue;\n }\n throw new InvalidResultStateError('collectFirstOkAsync');\n } catch (error) {\n // Wenn das Promise selbst rejected, behandeln wir es als Error\n errors.push(error as ErrValueOfInput<Inputs[number]>);\n }\n }\n\n return err<ErrValueOfInput<Inputs[number]>[], OkValueOfInput<Inputs[number]>>(errors);\n}\n","import type { Awaitable } from './pipeable';\nimport type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Parallel-Variante von `collectFirstOkAsync`.\n *\n * - Startet alle Inputs sofort (Promises oder Thunks).\n * - Gibt das erste `Ok` zurück, sobald es verfügbar ist.\n * - Wenn kein `Ok` gefunden wird, gibt ein `Err` mit allen Error-Werten (in Input-Reihenfolge) zurück.\n * - Rejections werden als `ErrValue` behandelt (`caught as ErrValue`).\n * - Wenn mehrere Inputs ein `Ok` liefern, gewinnt das zuerst abgeschlossene Ergebnis.\n * Bei gleichzeitiger Completion gewinnt das zuerst beobachtete Ergebnis.\n * - Wenn kein `Ok` kommt und mindestens ein Input nie settled, bleibt das Promise offen.\n */\nexport async function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n type OkValue = OkValueOfInput<Inputs[number]>;\n type ErrValue = ErrValueOfInput<Inputs[number]>;\n\n if (inputs.length === 0) {\n return err<ErrValue[], OkValue>([]);\n }\n\n const started = inputs.map((input) =>\n typeof input === 'function' ? Promise.resolve().then(input) : input\n );\n\n const firstOk = new Promise<Result<OkValue, ErrValue[]>>((resolve) => {\n for (const promise of started) {\n promise\n .then((result) => {\n if (result.isOk()) {\n resolve(ok<OkValue, ErrValue[]>(result.value as OkValue));\n }\n })\n .catch(() => {\n // Ignored here; handled in allSettled below.\n });\n }\n });\n\n const allErrors = Promise.allSettled(started).then((settled) => {\n const errors: ErrValue[] = [];\n for (const entry of settled) {\n if (entry.status === 'fulfilled') {\n const result = entry.value;\n if (result.isErr()) {\n errors.push(result.error as ErrValue);\n } else if (!result.isOk()) {\n errors.push(new InvalidResultStateError('collectFirstOkParallelAsync') as ErrValue);\n }\n } else {\n errors.push(entry.reason as ErrValue);\n }\n }\n return err<ErrValue[], OkValue>(errors);\n });\n\n return Promise.race([firstOk, allErrors]);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Kombiniert eine Liste von Results.\n * Gibt Ok(values) nur zurück wenn alle Ok sind, sonst Err([errors]).\n */\nexport function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Result<T[], E[]> {\n const values: T[] = [];\n const errors: E[] = [];\n\n for (const result of results) {\n if (result.isOk()) {\n values.push(result.value);\n continue;\n }\n if (result.isErr()) {\n errors.push(result.error);\n continue;\n }\n throw new InvalidResultStateError('collectAllErrors');\n }\n\n return errors.length === 0 ? ok(values) : err<E[], T[]>(errors);\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Partitioniert Results in Ok-Werte und Err-Fehler.\n */\nexport function partition<const Results extends readonly Result<any, any>[]>(\n results: Results\n): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>] {\n const oks: Array<OkValueOf<Results[number]>> = [];\n const errs: Array<ErrValueOf<Results[number]>> = [];\n\n for (const result of results) {\n if (result.isOk()) {\n oks.push(result.value as OkValueOf<Results[number]>);\n continue;\n }\n if (result.isErr()) {\n errs.push(result.error as ErrValueOf<Results[number]>);\n continue;\n }\n throw new InvalidResultStateError('partition');\n }\n\n return [oks, errs];\n}\n","import type { Result } from './result';\n\n/**\n * Flacht ein nested Result ab.\n * Result<Result<T, E>, E> → Result<T, E>\n * Entspricht Rust `flatten`.\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n if (result.isOk()) {\n return result.value;\n }\n return result as unknown as Result<T, E>;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Konvertiert ein Result zu einem Promise.\n * Ok → resolve(value), Err → reject(error)\n */\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n if (result.isOk()) {\n return Promise.resolve(result.value);\n }\n if (result.isErr()) return Promise.reject(result.error);\n throw new InvalidResultStateError('toPromise');\n}\n","import type { Result } from './result';\n\n/**\n * Konvertiert ein Result zu `T | null`.\n * Ok → value, Err → null\n */\nexport function toNullable<T, E>(result: Result<T, E>): T | null {\n if (result.isOk()) return result.value;\n return null;\n}\n","import type { Ok, Result } from './result';\n\n/**\n * Prüft ob ein Result Ok ist.\n * Pure function Alternative zur Instanz-Methode.\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T, E> {\n return result.isOk();\n}\n","import type { Err, Result } from './result';\n\n/**\n * Prüft ob ein Result Err ist.\n * Pure function Alternative zur Instanz-Methode.\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<T, E> {\n return result.isErr();\n}\n","import type { Result } from './result';\n\n/**\n * Prüft ob das Result einen bestimmten Wert enthält.\n * Entspricht Rust `contains`.\n */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n if (!result.isOk()) return false;\n return result.value === value;\n}\n","import type { Result } from './result';\n\n/**\n * Prüft ob das Result einen bestimmten Fehler enthält.\n * Analog zu `contains` für den Err-Fall.\n */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n if (!result.isErr()) return false;\n return result.error === error;\n}\n"],"mappings":"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"}
1
+ {"version":3,"file":"index.cjs","names":["ret: any","#error","#matched","#value","isResult","#makeErr","#resolved","mapErr","right","left","errors: Array<AE | BE>","errors: Array<ErrValueOf<Results[number]>>","input: unknown","step: IteratorResult<Y, R>","values: T[]","out: Partial<Out>","errors: Array<ErrValueOfInput<Inputs[number]>>","errors: ErrValue[]","values: T[]","errors: E[]","oks: Array<OkValueOf<Results[number]>>","errs: Array<ErrValueOf<Results[number]>>"],"sources":["../src/core/pipeable.ts","../src/errors.ts","../src/core/matcher.ts","../src/core/map.ts","../src/core/mapErr.ts","../src/core/mapBoth.ts","../src/core/flatMap.ts","../src/core/zip.ts","../src/core/tap.ts","../src/core/filter.ts","../src/core/match.ts","../src/core/recover.ts","../src/core/swap.ts","../src/core/tryCatch.ts","../src/core/tryMap.ts","../src/core/collectFirstOk.ts","../src/core/mapAsync.ts","../src/core/mapErrAsync.ts","../src/core/flatMapAsync.ts","../src/core/tapAsync.ts","../src/core/filterAsync.ts","../src/core/matchAsync.ts","../src/core/tryCatchAsync.ts","../src/core/tryMapAsync.ts","../src/core/result.ts","../src/core/isResult.ts","../src/gen.ts","../src/core/fold.ts","../src/core/foldAsync.ts","../src/core/unwrap.ts","../src/core/unwrapOr.ts","../src/core/unwrapOrElse.ts","../src/core/unwrapOrDefault.ts","../src/core/unwrapOrThrow.ts","../src/core/unwrapErr.ts","../src/core/expectResult.ts","../src/core/expectErr.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts","../src/core/sequence.ts","../src/core/sequenceRecord.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts","../src/core/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":["export type UnaryFunction<Input, Output> = (input: Input) => Output;\nexport type Awaitable<T> = T | Promise<T>;\n\nexport abstract class Pipeable {\n // -------------------------------------------------------------------------\n // PIPE (Synchron)\n // -------------------------------------------------------------------------\n\n pipe<A>(this: A): A;\n pipe<A, B>(this: A, ab: UnaryFunction<A, B>): B;\n pipe<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>): C;\n pipe<A, B, C, D>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>): D;\n pipe<A, B, C, D, E>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>\n ): E;\n pipe<A, B, C, D, E, F>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>\n ): F;\n pipe<A, B, C, D, E, F, G>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>\n ): G;\n pipe<A, B, C, D, E, F, G, H>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>\n ): H;\n pipe<A, B, C, D, E, F, G, H, I>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>\n ): I;\n pipe<A, B, C, D, E, F, G, H, I, J>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>\n ): J;\n pipe<A, B, C, D, E, F, G, H, I, J, K>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>\n ): K;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>\n ): L;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>\n ): M;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>\n ): N;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>\n ): O;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>\n ): P;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>\n ): Q;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>\n ): R;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>,\n rs: UnaryFunction<R, S>\n ): S;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>,\n rs: UnaryFunction<R, S>,\n st: UnaryFunction<S, T>\n ): T;\n pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<B, C>,\n cd: UnaryFunction<C, D>,\n de: UnaryFunction<D, E>,\n ef: UnaryFunction<E, F>,\n fg: UnaryFunction<F, G>,\n gh: UnaryFunction<G, H>,\n hi: UnaryFunction<H, I>,\n ij: UnaryFunction<I, J>,\n jk: UnaryFunction<J, K>,\n kl: UnaryFunction<K, L>,\n lm: UnaryFunction<L, M>,\n mn: UnaryFunction<M, N>,\n no: UnaryFunction<N, O>,\n op: UnaryFunction<O, P>,\n pq: UnaryFunction<P, Q>,\n qr: UnaryFunction<Q, R>,\n rs: UnaryFunction<R, S>,\n st: UnaryFunction<S, T>,\n tu: UnaryFunction<T, U>\n ): U;\n\n pipe(this: any, ...ops: Array<UnaryFunction<any, any>>): any {\n let ret: any = this;\n for (const op of ops) {\n ret = op(ret);\n }\n return ret;\n }\n\n // -------------------------------------------------------------------------\n // PIPE ASYNC (Asynchron)\n // -------------------------------------------------------------------------\n\n pipeAsync<A>(this: A): Promise<A>;\n pipeAsync<A, B>(this: A, ab: UnaryFunction<A, B>): Promise<Awaited<B>>;\n pipeAsync<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>): Promise<Awaited<C>>;\n pipeAsync<A, B, C, D>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>\n ): Promise<Awaited<D>>;\n pipeAsync<A, B, C, D, E>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>\n ): Promise<Awaited<E>>;\n pipeAsync<A, B, C, D, E, F>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>\n ): Promise<Awaited<F>>;\n pipeAsync<A, B, C, D, E, F, G>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>\n ): Promise<Awaited<G>>;\n pipeAsync<A, B, C, D, E, F, G, H>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>\n ): Promise<Awaited<H>>;\n pipeAsync<A, B, C, D, E, F, G, H, I>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>\n ): Promise<Awaited<I>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>\n ): Promise<Awaited<J>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>\n ): Promise<Awaited<K>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>\n ): Promise<Awaited<L>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>\n ): Promise<Awaited<M>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>\n ): Promise<Awaited<N>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>\n ): Promise<Awaited<O>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>\n ): Promise<Awaited<P>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>\n ): Promise<Awaited<Q>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>\n ): Promise<Awaited<R>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>,\n rs: UnaryFunction<Awaited<R>, S>\n ): Promise<Awaited<S>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>,\n rs: UnaryFunction<Awaited<R>, S>,\n st: UnaryFunction<Awaited<S>, T>\n ): Promise<Awaited<T>>;\n pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(\n this: A,\n ab: UnaryFunction<A, B>,\n bc: UnaryFunction<Awaited<B>, C>,\n cd: UnaryFunction<Awaited<C>, D>,\n de: UnaryFunction<Awaited<D>, E>,\n ef: UnaryFunction<Awaited<E>, F>,\n fg: UnaryFunction<Awaited<F>, G>,\n gh: UnaryFunction<Awaited<G>, H>,\n hi: UnaryFunction<Awaited<H>, I>,\n ij: UnaryFunction<Awaited<I>, J>,\n jk: UnaryFunction<Awaited<J>, K>,\n kl: UnaryFunction<Awaited<K>, L>,\n lm: UnaryFunction<Awaited<L>, M>,\n mn: UnaryFunction<Awaited<M>, N>,\n no: UnaryFunction<Awaited<N>, O>,\n op: UnaryFunction<Awaited<O>, P>,\n pq: UnaryFunction<Awaited<P>, Q>,\n qr: UnaryFunction<Awaited<Q>, R>,\n rs: UnaryFunction<Awaited<R>, S>,\n st: UnaryFunction<Awaited<S>, T>,\n tu: UnaryFunction<Awaited<T>, U>\n ): Promise<Awaited<U>>;\n\n async pipeAsync(this: any, ...ops: Array<(a: any) => Awaitable<any>>): Promise<any> {\n let ret: any = this;\n for (const op of ops) {\n ret = await op(ret);\n }\n return ret;\n }\n}\n\n","export const ERR_INVALID_STATE = 'ERR_INVALID_STATE' as const;\nexport const ERR_TASK_YIELD_NOT_RESULT = 'ERR_TASK_YIELD_NOT_RESULT' as const;\nexport const ERR_MATCH_ON_OK = 'ERR_MATCH_ON_OK' as const;\nexport const ERR_UNWRAP_ON_ERR = 'ERR_UNWRAP_ON_ERR' as const;\nexport const ERR_UNWRAP_ERR_ON_OK = 'ERR_UNWRAP_ERR_ON_OK' as const;\nexport const ERR_EXPECT_OK = 'ERR_EXPECT_OK' as const;\nexport const ERR_EXPECT_ERR = 'ERR_EXPECT_ERR' as const;\n\nexport type ResultErrorCode =\n | typeof ERR_INVALID_STATE\n | typeof ERR_TASK_YIELD_NOT_RESULT\n | typeof ERR_MATCH_ON_OK\n | typeof ERR_UNWRAP_ON_ERR\n | typeof ERR_UNWRAP_ERR_ON_OK\n | typeof ERR_EXPECT_OK\n | typeof ERR_EXPECT_ERR;\n\nconst formatResultErrorMessage = (code: ResultErrorCode, message: string, context?: string): string => {\n if (context) {\n return `${code}: ${message} (context: ${context})`;\n }\n return `${code}: ${message}`;\n};\n\nexport class ResultError extends Error {\n readonly code: ResultErrorCode;\n readonly context?: string;\n\n constructor(message: string, code: ResultErrorCode, context?: string) {\n super(formatResultErrorMessage(code, message, context));\n this.code = code;\n this.context = context;\n this.name = new.target.name;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n\nexport class ResultTypeError extends TypeError {\n readonly code: ResultErrorCode;\n readonly context?: string;\n\n constructor(message: string, code: ResultErrorCode, context?: string) {\n super(formatResultErrorMessage(code, message, context));\n this.code = code;\n this.context = context;\n this.name = new.target.name;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n\nconst INVALID_RESULT_STATE_MESSAGE = 'Unreachable: Result is neither Ok nor Err';\n\nexport class InvalidResultStateError extends ResultError {\n constructor(context?: string) {\n super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_STATE, context);\n }\n}\n\nexport class TaskYieldNotResultError extends ResultTypeError {\n readonly yieldedValue: unknown;\n\n constructor(yieldedValue: unknown) {\n super('task() expected yielded values to be Result. Use `yield*` on a Result.', ERR_TASK_YIELD_NOT_RESULT);\n this.yieldedValue = yieldedValue;\n }\n}\n\nexport class MatchOnOkError extends ResultTypeError {\n constructor() {\n super('match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.', ERR_MATCH_ON_OK);\n }\n}\n\nexport class UnwrapOnErrError extends ResultTypeError {\n readonly errorValue: unknown;\n\n constructor(errorValue: unknown) {\n super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);\n this.errorValue = errorValue;\n }\n}\n\nexport class UnwrapErrOnOkError extends ResultTypeError {\n readonly okValue: unknown;\n\n constructor(okValue: unknown) {\n super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);\n this.okValue = okValue;\n }\n}\n\nexport class ExpectOkError extends ResultError {\n readonly expectedMessage: string;\n\n constructor(expectedMessage: string) {\n super(expectedMessage, ERR_EXPECT_OK);\n this.expectedMessage = expectedMessage;\n }\n}\n\nexport class ExpectErrError extends ResultError {\n readonly expectedMessage: string;\n\n constructor(expectedMessage: string) {\n super(expectedMessage, ERR_EXPECT_ERR);\n this.expectedMessage = expectedMessage;\n }\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\nexport type Ctor<T> = abstract new (...args: any[]) => T;\nexport type TypeGuard<E, A extends E> = (error: E) => error is A;\n\n/**\n * Matcher for Err values (returns an arbitrary return type, e.g. string messages).\n *\n * - `.when(Ctor, handler)` matches via `instanceof`\n * - `.whenGuard(guard, handler)` matches via Type-Guard\n * - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`)\n */\nexport class ErrorMatchBuilder<E, R> {\n readonly #error: unknown;\n readonly #matched: boolean;\n readonly #value: unknown;\n\n constructor(error: unknown, matched = false, value?: unknown) {\n this.#error = error;\n this.#matched = matched;\n this.#value = value;\n Object.freeze(this);\n }\n\n when<C extends Ctor<E>, R1>(\n ctor: C,\n handler: (error: InstanceType<C>) => R1\n ): ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1> {\n if (this.#matched) return this as unknown as ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1>;\n\n if (this.#error instanceof ctor) {\n return new ErrorMatchBuilder(this.#error, true, handler(this.#error as InstanceType<C>)) as unknown as ErrorMatchBuilder<\n Exclude<E, InstanceType<C>>,\n R | R1\n >;\n }\n\n return this as unknown as ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R | R1>;\n }\n\n whenGuard<A extends E, R1>(\n guard: TypeGuard<E, A>,\n handler: (error: A) => R1\n ): ErrorMatchBuilder<Exclude<E, A>, R | R1> {\n if (this.#matched) return this as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n\n const error = this.#error as E;\n if (guard(error)) {\n return new ErrorMatchBuilder(this.#error, true, handler(error)) as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n }\n\n return this as unknown as ErrorMatchBuilder<Exclude<E, A>, R | R1>;\n }\n\n otherwise<R2>(handler: (error: E) => R2): R | R2 {\n if (this.#matched) return this.#value as R;\n return handler(this.#error as E);\n }\n\n run(this: ErrorMatchBuilder<never, R>): R {\n if (this.#matched) return this.#value as R;\n throw this.#error;\n }\n}\n\ntype OkOfReturn<R> = R extends Result<infer T, any> ? T : never;\ntype ErrOfReturn<R> = R extends Result<any, infer E> ? E : R;\n\ntype ErrFactory = <E>(error: E) => Result<never, E>;\n\nfunction isResult(value: unknown): value is Result<any, any> {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'isOk' in value &&\n typeof (value as any).isOk === 'function' &&\n 'isErr' in value &&\n typeof (value as any).isErr === 'function'\n );\n}\n\n/**\n * Matcher for `Result` Errors, which returns a `Result` again.\n *\n * Handlers may:\n * - return a `Result` (is returned directly)\n * - return an Error value (is automatically wrapped into `Err(error)`)\n */\nexport class ErrMatchBuilder<T, E, OutT, OutE> {\n readonly #makeErr: ErrFactory;\n readonly #error: unknown;\n readonly #resolved: Result<any, any> | undefined;\n\n private constructor(makeErr: ErrFactory, error: unknown, resolved?: Result<any, any>) {\n this.#makeErr = makeErr;\n this.#error = error;\n this.#resolved = resolved;\n Object.freeze(this);\n }\n\n static fromResult<T, E>(result: Result<T, E>, makeErr: ErrFactory): ErrMatchBuilder<T, E, never, never> {\n if (result.isOk()) return new ErrMatchBuilder<T, E, never, never>(makeErr, undefined, result);\n if (result.isErr()) return new ErrMatchBuilder<T, E, never, never>(makeErr, result.error);\n throw new InvalidResultStateError('ErrMatchBuilder.fromResult');\n }\n\n when<C extends Ctor<E>, R1>(\n ctor: C,\n handler: (error: InstanceType<C>) => R1\n ): ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>> {\n if (this.#resolved) {\n return this as unknown as ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n }\n\n if (this.#error instanceof ctor) {\n const out = handler(this.#error as InstanceType<C>);\n const resolved = isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R1>);\n return new ErrMatchBuilder(this.#makeErr, this.#error, resolved) as unknown as ErrMatchBuilder<\n T,\n Exclude<E, InstanceType<C>>,\n OutT | OkOfReturn<R1>,\n OutE | ErrOfReturn<R1>\n >;\n }\n\n return this as unknown as ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n }\n\n whenGuard<A extends E, R1>(\n guard: TypeGuard<E, A>,\n handler: (error: A) => R1\n ): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>> {\n if (this.#resolved) return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n\n const error = this.#error as E;\n if (guard(error)) {\n const out = handler(error);\n const resolved = isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R1>);\n return new ErrMatchBuilder(this.#makeErr, this.#error, resolved) as unknown as ErrMatchBuilder<\n T,\n Exclude<E, A>,\n OutT | OkOfReturn<R1>,\n OutE | ErrOfReturn<R1>\n >;\n }\n\n return this as unknown as ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn<R1>, OutE | ErrOfReturn<R1>>;\n }\n\n otherwise<R2>(handler: (error: E) => R2): Result<T | OutT | OkOfReturn<R2>, OutE | ErrOfReturn<R2>> {\n if (this.#resolved) return this.#resolved as Result<T | OutT | OkOfReturn<R2>, OutE | ErrOfReturn<R2>>;\n\n const out = handler(this.#error as E);\n return (isResult(out) ? out : this.#makeErr(out as ErrOfReturn<R2>)) as Result<\n T | OutT | OkOfReturn<R2>,\n OutE | ErrOfReturn<R2>\n >;\n }\n\n run(this: ErrMatchBuilder<T, never, OutT, OutE>): Result<T | OutT, OutE> {\n if (this.#resolved) return this.#resolved as Result<T | OutT, OutE>;\n throw this.#error;\n }\n}\n","import type { Result } from './result';\nimport { ok } from './result';\n\n/**\n * Transforms the value (Ok case).\n * Corresponds to Rust `map`.\n */\nexport function map<T, E, U>(project: (value: T) => U) {\n return (source: Result<T, E>): Result<U, E> => {\n if (source.isOk()) {\n return ok(project(source.value));\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Transforms the error (Err case).\n * Corresponds to Rust `map_err`.\n */\nexport function mapErr<T, E, F>(project: (error: E) => F) {\n return (source: Result<T, E>): Result<T, F> => {\n if (source.isErr()) {\n return err(project(source.error));\n }\n return source as unknown as Result<T, F>;\n };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms both the Ok value and the Err error.\n * Corresponds to FP `bimap` / `mapBoth`.\n */\nexport function mapBoth<T, E, U, F>(mapOk: (value: T) => U, mapErr: (error: E) => F) {\n return (source: Result<T, E>): Result<U, F> => {\n if (source.isOk()) {\n return ok<U, F>(mapOk(source.value));\n }\n if (source.isErr()) {\n return err<F, U>(mapErr(source.error));\n }\n throw new InvalidResultStateError('mapBoth');\n };\n}\n\n/**\n * Alias for `mapBoth`.\n */\nexport const bimap = mapBoth;\n","import type { Result } from './result';\n\n/**\n * Chains another operation that returns a Result.\n * Corresponds to Rust `and_then` or JS `flatMap`.\n */\nexport function flatMap<T, E, U>(project: (value: T) => Result<U, E>) {\n return (source: Result<T, E>): Result<U, E> => {\n if (source.isOk()) {\n return project(source.value);\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\nimport { err, ok } from './result';\n\nfunction zipImpl<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE> {\n if (left.isErr()) return left as unknown as Result<[A, B], AE | BE>;\n if (right.isErr()) return right as unknown as Result<[A, B], AE | BE>;\n if (left.isOk() && right.isOk()) return ok<[A, B], AE | BE>([left.value, right.value]);\n throw new InvalidResultStateError('zip');\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * Short-circuits on the first Err (left before right).\n */\nexport function zip<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE>;\nexport function zip<A, AE, B, BE>(right: Result<B, BE>): (left: Result<A, AE>) => Result<[A, B], AE | BE>;\nexport function zip(...args: unknown[]): unknown {\n if (args.length === 1) {\n const right = args[0] as Result<any, any>;\n return (left: Result<any, any>) => zipImpl(left, right);\n }\n const [left, right] = args as [Result<any, any>, Result<any, any>];\n return zipImpl(left, right);\n}\n\nfunction combineImpl<A, AE, B, BE>(\n left: Result<A, AE>,\n right: Result<B, BE>\n): Result<[A, B], Array<AE | BE>> {\n if (left.isOk() && right.isOk()) {\n return ok<[A, B], Array<AE | BE>>([left.value, right.value]);\n }\n\n const errors: Array<AE | BE> = [];\n if (left.isErr()) errors.push(left.error as AE | BE);\n if (right.isErr()) errors.push(right.error as AE | BE);\n\n return err<Array<AE | BE>, [A, B]>(errors);\n}\n\n/**\n * Combines two Results and collects errors.\n * - Ok only if both are Ok\n * - Err([errors]) if at least one is Err (left before right)\n */\nexport function combine<A, AE, B, BE>(\n left: Result<A, AE>,\n right: Result<B, BE>\n): Result<[A, B], Array<AE | BE>>;\nexport function combine<A, AE, B, BE>(\n right: Result<B, BE>\n): (left: Result<A, AE>) => Result<[A, B], Array<AE | BE>>;\nexport function combine(...args: unknown[]): unknown {\n if (args.length === 1) {\n const right = args[0] as Result<any, any>;\n return (left: Result<any, any>) => combineImpl(left, right);\n }\n const [left, right] = args as [Result<any, any>, Result<any, any>];\n return combineImpl(left, right);\n}\n","import type { Result } from './result';\n\n/**\n * Executes a side effect (logging, debugging) without changing the Result.\n * Corresponds to Rust `inspect` / `inspect_err`.\n */\nexport function tap<T, E>(observer: { ok?: (val: T) => void; err?: (e: E) => void }) {\n return (source: Result<T, E>): Result<T, E> => {\n if (source.isOk() && observer.ok) observer.ok(source.value);\n if (source.isErr() && observer.err) observer.err(source.error);\n return source;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Checks a condition. If false, the Result becomes Err.\n * Corresponds to Rust `filter` (partially).\n */\nexport function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E) {\n return (source: Result<T, E>): Result<T, E> => {\n if (source.isOk()) {\n if (predicate(source.value)) {\n return source;\n }\n return err(errorFn());\n }\n return source;\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Resolves the Result. The end of the pipe.\n * Corresponds to Rust `match`.\n */\nexport function match<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n return (source: Result<T, E>): R => {\n if (source.isOk()) {\n return handlers.ok(source.value);\n }\n if (source.isErr()) return handlers.err(source.error);\n throw new InvalidResultStateError('match');\n };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Recover: converts Err to Ok(defaultValue).\n * Result is guaranteed to be Ok → Error type becomes `never`.\n */\nexport function recover<T, E, F>(defaultValue: F) {\n return (source: Result<T, E>): Result<T | F, never> => {\n if (source.isOk()) return source as unknown as Result<T | F, never>;\n if (source.isErr()) return ok(defaultValue);\n throw new InvalidResultStateError('recover');\n };\n}\n\n/**\n * Like `recover`, but calculates the default value based on the error.\n */\nexport function recoverWith<T, E, F>(fn: (error: E) => F) {\n return (source: Result<T, E>): Result<T | F, never> => {\n if (source.isOk()) return source as unknown as Result<T | F, never>;\n if (source.isErr()) return ok(fn(source.error));\n throw new InvalidResultStateError('recoverWith');\n };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Swaps Ok and Err.\n * Result<T, E> → Result<E, T>\n */\nexport function swap<T, E>(result: Result<T, E>): Result<E, T> {\n if (result.isOk()) {\n return err<T, E>(result.value);\n }\n if (result.isErr()) {\n return ok<E, T>(result.error);\n }\n throw new InvalidResultStateError('swap');\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Executes a function and catches exceptions.\n * Converts exceptions into Result<E>.\n * Corresponds to Rust `Result::from` for fallible operations.\n */\nexport function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E) {\n return (source: Result<any, any>): Result<T, E> => {\n if (source.isErr()) return source as unknown as Result<T, E>;\n\n try {\n return ok(fn());\n } catch (error) {\n return err(errorMapper ? errorMapper(error) : error as E);\n }\n };\n}","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Like `map`, but catches exceptions and converts them to Err.\n */\nexport function tryMap<T, E, U, F = unknown>(\n project: (value: T) => U,\n errorMapper?: (error: unknown) => F\n) {\n return (source: Result<T, E>): Result<U, E | F> => {\n if (source.isErr()) {\n return source as unknown as Result<U, E | F>;\n }\n\n try {\n if (source.isOk()) return ok<U, E | F>(project(source.value));\n throw new InvalidResultStateError('tryMap');\n } catch (error) {\n return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n }\n };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Parse a set of `Result`s, short-circuits when an input value is `Ok`.\n * If no `Ok` is found, returns an `Err` containing the collected error values.\n * Useful for \"try multiple approaches until one works\" patterns.\n */\nexport function collectFirstOk<const Results extends readonly Result<any, any>[]>(\n results: Results\n): Result<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]> {\n const errors: Array<ErrValueOf<Results[number]>> = [];\n\n for (const result of results) {\n if (result.isOk()) {\n return ok<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]>(\n result.value as OkValueOf<Results[number]>\n );\n }\n if (result.isErr()) {\n errors.push(result.error as ErrValueOf<Results[number]>);\n continue;\n }\n throw new InvalidResultStateError('collectFirstOk');\n }\n\n return err<ErrValueOf<Results[number]>[], OkValueOf<Results[number]>>(errors);\n}\n","import type { Result } from './result';\nimport { ok } from './result';\n\n/**\n * Async version of map.\n */\nexport function mapAsync<T, E, U>(project: (value: T) => Promise<U>) {\n return async (source: Result<T, E>): Promise<Result<U, E>> => {\n if (source.isOk()) {\n return ok(await project(source.value));\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Async version of mapErr.\n */\nexport function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>) {\n return async (source: Result<T, E>): Promise<Result<T, F>> => {\n if (source.isErr()) {\n return err(await project(source.error));\n }\n return source as unknown as Result<T, F>;\n };\n}\n","import type { Result } from './result';\n\n/**\n * Async version of flatMap.\n */\nexport function flatMapAsync<T, E, U>(project: (value: T) => Promise<Result<U, E>>) {\n return async (source: Result<T, E>): Promise<Result<U, E>> => {\n if (source.isOk()) {\n return await project(source.value);\n }\n return source as unknown as Result<U, E>;\n };\n}\n","import type { Result } from './result';\n\n/**\n * Async version of tap.\n */\nexport function tapAsync<T, E>(observer: { ok?: (val: T) => Promise<void>; err?: (e: E) => Promise<void> }) {\n return async (source: Result<T, E>): Promise<Result<T, E>> => {\n if (source.isOk() && observer.ok) await observer.ok(source.value);\n if (source.isErr() && observer.err) await observer.err(source.error);\n return source;\n };\n}\n","import type { Result } from './result';\nimport { err } from './result';\n\n/**\n * Async version of filter.\n */\nexport function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>) {\n return async (source: Result<T, E>): Promise<Result<T, E>> => {\n if (source.isOk()) {\n if (await predicate(source.value)) {\n return source;\n }\n return err(await errorFn());\n }\n return source;\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of match.\n */\nexport function matchAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n return async (source: Result<T, E>): Promise<R> => {\n if (source.isOk()) {\n return await handlers.ok(source.value);\n }\n if (source.isErr()) return await handlers.err(source.error);\n throw new InvalidResultStateError('matchAsync');\n };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Async version of tryCatch.\n */\nexport function tryCatchAsync<T, E = unknown>(\n fn: () => Promise<T>,\n errorMapper?: (error: unknown) => E\n) {\n return async (source: Result<any, any>): Promise<Result<T, E>> => {\n if (source.isErr()) return source as unknown as Result<T, E>;\n\n try {\n return ok(await fn());\n } catch (error) {\n return err(errorMapper ? errorMapper(error) : error as E);\n }\n };\n}","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of tryMap.\n */\nexport function tryMapAsync<T, E, U, F = unknown>(\n project: (value: T) => Promise<U>,\n errorMapper?: (error: unknown) => F\n) {\n return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n if (source.isErr()) {\n return source as unknown as Result<U, E | F>;\n }\n\n try {\n if (source.isOk()) return ok<U, E | F>(await project(source.value));\n throw new InvalidResultStateError('tryMapAsync');\n } catch (error) {\n return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n }\n };\n}\n","import { Pipeable } from './pipeable';\nimport { ErrMatchBuilder, ErrorMatchBuilder } from './matcher';\nimport { InvalidResultStateError, MatchOnOkError } from '../errors';\n\n// Re-export pipe operators for convenience\nexport { map } from './map';\nexport { mapErr } from './mapErr';\nexport { bimap, mapBoth } from './mapBoth';\nexport { flatMap } from './flatMap';\nexport { zip, combine } from './zip';\nexport { tap } from './tap';\nexport { filter } from './filter';\nexport { match } from './match';\nexport { recover, recoverWith } from './recover';\nexport { swap } from './swap';\nexport { tryCatch } from './tryCatch';\nexport { tryMap } from './tryMap';\nexport { collectFirstOk } from './collectFirstOk';\n\n// Async variants\nexport { mapAsync } from './mapAsync';\nexport { mapErrAsync } from './mapErrAsync';\nexport { flatMapAsync } from './flatMapAsync';\nexport { tapAsync } from './tapAsync';\nexport { filterAsync } from './filterAsync';\nexport { matchAsync } from './matchAsync';\nexport { tryCatchAsync } from './tryCatchAsync';\nexport { tryMapAsync } from './tryMapAsync';\n\n// --- 1. Helper Types ---\n\n// An operator is a function that takes a Result and returns something else.\nexport type OperatorFunction<T, E, R> = (input: Result<T, E>) => R;\nexport type { Awaitable } from './pipeable';\nexport type AsyncOperatorFunction<T, E, R> = (input: Result<T, E>) => Promise<R>;\n\n// --- 2. Result Types ---\n\nexport type ResultType<T, E> = { readonly _tag: 'Ok'; readonly value: T } | { readonly _tag: 'Err'; readonly error: E };\n\nexport type Result<T, E> = Ok<T, E> | Err<T, E>;\ntype OkValue<R> = R extends { readonly _tag: 'Ok'; readonly value: infer T } ? T : never;\n\nabstract class ResultBase extends Pipeable {\n abstract readonly _tag: 'Ok' | 'Err';\n abstract readonly value: unknown;\n abstract readonly error: unknown;\n\n // Basic helpers for internal access in operators\n isOk<T, E>(this: Result<T, E>): this is Ok<T, E> {\n return this._tag === 'Ok';\n }\n\n isErr<T, E>(this: Result<T, E>): this is Err<T, E> {\n return this._tag === 'Err';\n }\n\n unwrapOr<T, E>(this: Result<T, E>, defaultValue: T): T {\n return this._tag === 'Ok' ? this.value : defaultValue;\n }\n\n /**\n * Folds the Result into a single value by applying one of two functions.\n */\n fold<T, E, R1, R2 = R1>(this: Result<T, E>, onOk: (value: T) => R1, onErr: (error: E) => R2): R1 | R2 {\n if (this._tag === 'Ok') return onOk(this.value);\n if (this._tag === 'Err') return onErr(this.error);\n throw new InvalidResultStateError('Result.fold');\n }\n\n /**\n * Enables `yield* result` in generators (Do-notation).\n *\n * The iterator yields the `Result` itself; the runner (see `task`) decides:\n * - Ok → sends back the Ok value (`next(value)`), `yield*` yields `T`\n * - Err → aborts and returns the Err Result\n */\n *[Symbol.iterator](): Generator<unknown, OkValue<this>, unknown> {\n return (yield this) as OkValue<this>;\n }\n\n /**\n * Matches on the Err value via `.when(...)` chain.\n *\n * Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,\n * e.g. inside `if (result.isErr()) { ... }`.\n */\n match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never> {\n if (this._tag === 'Err') return new ErrorMatchBuilder(this.error);\n throw new MatchOnOkError();\n }\n\n /**\n * Matches on the Err value, but normalizes every branch to a `Result`:\n * - Handlers may return a `Result` (is returned directly)\n * - or an Error value (is wrapped into `Err(error)`)\n */\n matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never> {\n const makeErr = <ErrValue>(error: ErrValue) => err<ErrValue, never>(error);\n return ErrMatchBuilder.fromResult(this, makeErr);\n }\n\n /**\n * Serializes the Result into a simple object format.\n * Preserves the original types.\n */\n serialize<T, E>(this: Result<T, E>): { isSuccess: boolean; data?: T; error?: E } {\n if (this._tag === 'Ok') return { isSuccess: true, data: this.value };\n return { isSuccess: false, error: this.error };\n }\n\n /**\n * Serializes the Result into a user-friendly format.\n * Converts Errors to readable strings.\n */\n toUserFriendly<T, E>(this: Result<T, E>): { isSuccess: boolean; data?: T; error?: string } {\n if (this._tag === 'Ok') return { isSuccess: true, data: this.value };\n\n const error = this.error;\n const errorMessage =\n error && typeof error === 'object' && 'message' in error ? (error as any).message : String(error);\n\n return { isSuccess: false, error: errorMessage };\n }\n}\n\nexport class Ok<T, E = never> extends ResultBase {\n readonly _tag = 'Ok' as const;\n readonly value: T;\n readonly error = undefined;\n\n constructor(value: T) {\n super();\n this.value = value;\n Object.freeze(this);\n }\n}\n\nexport class Err<T = never, E = never> extends ResultBase {\n readonly _tag = 'Err' as const;\n readonly value = undefined;\n readonly error: E;\n\n constructor(error: E) {\n super();\n this.error = error;\n Object.freeze(this);\n }\n}\n\nexport function ok(): Result<void, never>;\nexport function ok<T, E = never>(value: T): Result<T, E>;\nexport function ok<T, E = never>(value?: T): Result<T, E> {\n return new Ok<T, E>(value as T);\n}\n\nexport function err<E, T = never>(error: E): Result<T, E> {\n return new Err<T, E>(error);\n}\n\nexport function okIf<T, E>(condition: boolean, okValue: T, errValue: E): Result<T, E> {\n return condition ? ok<T, E>(okValue) : err<E, T>(errValue);\n}\n\nexport function okIfLazy<T, E>(condition: boolean, okFn: () => T, errFn: () => E): Result<T, E> {\n return condition ? ok<T, E>(okFn()) : err<E, T>(errFn());\n}\n\nexport function fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E> {\n if (value === null || value === undefined) {\n return err<E, NonNullable<T>>(error);\n }\n return ok<NonNullable<T>, E>(value as NonNullable<T>);\n}\n\nexport function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;\nexport function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>> {\n try {\n const value = await promise;\n return ok(value);\n } catch (error) {\n try {\n return err(errorMapper ? errorMapper(error) : (error as E));\n } catch (mapperError) {\n return err(mapperError as E);\n }\n }\n}\n\nexport function tryFn<T>(fn: () => T): Result<T, unknown> {\n try {\n return ok(fn());\n } catch (error) {\n return err(error);\n }\n}\n\nexport const Result = {\n ok,\n err,\n fromNullable,\n fromPromise,\n try: tryFn,\n};\n","import type { Result } from './result';\n\n/**\n * Checks whether a value is a Result.\n * Pure function alternative for runtime checks.\n */\nexport function isResult(value: unknown): value is Result<any, any> {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'isOk' in value &&\n typeof (value as { isOk?: unknown }).isOk === 'function' &&\n 'isErr' in value &&\n typeof (value as { isErr?: unknown }).isErr === 'function'\n );\n}\n","import type { Result } from './core/result';\nimport { err, ok } from './core/result';\nimport { isResult } from './core/isResult';\nimport { InvalidResultStateError, TaskYieldNotResultError } from './errors';\n\ntype AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturn<R> = Awaited<R>;\ntype OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;\ntype ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;\n\n/**\n * Generator-based do-notation for `Result`.\n *\n * Usage:\n * ```ts\n * const out = await task(async function* () {\n * const user = yield* await fromPromise(findUser(1));\n * const email = yield* validate(user.email);\n * return email;\n * });\n * ```\n */\nexport async function task<const Y, const R>(\n makeGenerator: () => AnyGenerator<Y, R, unknown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;\nexport async function task<const Y, const R, EThrown>(\n makeGenerator: () => AnyGenerator<Y, R, unknown>,\n onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;\nexport async function task<const Y, const R, EThrown>(\n makeGenerator: () => AnyGenerator<Y, R, unknown>,\n onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> {\n const iterator = makeGenerator();\n let input: unknown = undefined;\n\n while (true) {\n let step: IteratorResult<Y, R>;\n try {\n step = await iterator.next(input);\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n }\n\n if (step.done) {\n try {\n const awaited = await step.value;\n if (isResult(awaited)) {\n return awaited as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n }\n return ok<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>(awaited as OkOfReturn<R>);\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n }\n }\n\n const yielded = step.value as unknown;\n if (!isResult(yielded)) {\n throw new TaskYieldNotResultError(yielded);\n }\n\n if (yielded.isOk()) {\n input = yielded.value;\n continue;\n }\n\n if (yielded.isErr()) {\n try {\n if (typeof iterator.return === 'function') {\n await iterator.return(undefined as unknown as R);\n }\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n }\n\n return yielded as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n }\n\n throw new InvalidResultStateError('task');\n }\n}\n\nexport const gen = task;\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n return (source: Result<T, E>): R => {\n if (source.isOk()) {\n return handlers.ok(source.value);\n }\n if (source.isErr()) return handlers.err(source.error);\n throw new InvalidResultStateError('fold');\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n return async (source: Result<T, E>): Promise<R> => {\n if (source.isOk()) {\n return await handlers.ok(source.value);\n }\n if (source.isErr()) return await handlers.err(source.error);\n throw new InvalidResultStateError('foldAsync');\n };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapOnErrError } from '../errors';\n\n/**\n * Returns the value or throws an Error.\n * Corresponds to Rust `unwrap`.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n if (result.isOk()) {\n return result.value;\n }\n if (result.isErr()) throw new UnwrapOnErrError(result.error);\n throw new InvalidResultStateError('unwrap');\n}\n","import type { Result } from './result';\n\n/**\n * Returns the value or a default value.\n * Pure function alternative to the instance method.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n if (result.isOk()) return result.value;\n return defaultValue;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or calculates a default value using a function.\n * Corresponds to Rust `unwrap_or_else`.\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n if (result.isOk()) return result.value;\n if (result.isErr()) return fn(result.error);\n throw new InvalidResultStateError('unwrapOrElse');\n}\n","import type { Result } from './result';\nimport { unwrapOr } from './unwrapOr';\n\n/**\n * Alias for `unwrapOr`.\n * Corresponds to Rust `unwrap_or_default` (with explicit default value).\n */\nexport function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T {\n return unwrapOr(result, defaultValue);\n}\n\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws the original Err value (not wrapped).\n * Useful to preserve `Error` instances including stack traces.\n */\nexport function unwrapOrThrow<T, E>(result: Result<T, E>): T {\n if (result.isOk()) return result.value;\n if (result.isErr()) throw result.error;\n throw new InvalidResultStateError('unwrapOrThrow');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapErrOnOkError } from '../errors';\n\n/**\n * Returns the error or throws an Error.\n * Corresponds to Rust `unwrap_err`.\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n if (result.isErr()) {\n return result.error;\n }\n if (result.isOk()) throw new UnwrapErrOnOkError(result.value);\n throw new InvalidResultStateError('unwrapErr');\n}\n","import type { Result } from './result';\nimport { ExpectOkError } from '../errors';\n\n/**\n * Returns the value or throws an Error with a custom message.\n * Corresponds to Rust `expect`.\n */\nexport function expectResult<T, E>(result: Result<T, E>, message: string): T {\n if (result.isOk()) {\n return result.value;\n }\n throw new ExpectOkError(message);\n}\n","import type { Result } from './result';\nimport { ExpectErrError } from '../errors';\n\n/**\n * Returns the error or throws an Error with a custom message.\n * Corresponds to Rust `expect_err`.\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n if (result.isErr()) {\n return result.error;\n }\n throw new ExpectErrError(message);\n}\n","import type { Result } from './result';\n\n/**\n * Combines two Results. Returns the second one only if the first is Ok.\n * Corresponds to Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n return result.isOk() ? other : result as unknown as Result<U, E>;\n}","import type { Result } from './result';\n\n/**\n * Fallback to another Result if the first is Err.\n * Corresponds to Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n return result.isOk() ? result as unknown as Result<T, F> : other;\n}","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback with a function that returns a Result.\n * Corresponds to Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n if (result.isOk()) return result as unknown as Result<T, F>;\n if (result.isErr()) return fn(result.error);\n throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\n\n/**\n * Transforms the value or returns a default value.\n * Corresponds to Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n if (result.isOk()) return fn(result.value);\n return defaultValue;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or calculates a default value using a function.\n * Corresponds to Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n if (result.isOk()) return fn(result.value);\n if (result.isErr()) return defaultFn(result.error);\n throw new InvalidResultStateError('mapOrElse');\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines a list of Results into a single Result of a list.\n * Short-circuits on the first Err.\n * Analogous to Rust `collect::<Result<Vec<_>, _>>()`.\n */\nexport function sequence<T, E>(results: readonly Result<T, E>[]): Result<T[], E> {\n const values: T[] = [];\n\n for (const result of results) {\n if (result.isOk()) {\n values.push(result.value);\n continue;\n }\n if (result.isErr()) return result as unknown as Result<T[], E>;\n throw new InvalidResultStateError('sequence');\n }\n\n return ok(values);\n}\n\n/**\n * Alias for `sequence`.\n */\nexport function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E> {\n return sequence(results);\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Like `sequence`, but for Records/Objects.\n * Short-circuits on the first Err.\n */\nexport function sequenceRecord<const R extends Record<string, Result<any, any>>>(\n record: R\n): Result<{ [K in keyof R]: OkValueOf<R[K]> }, ErrValueOf<R[keyof R]>> {\n type Out = { [K in keyof R]: OkValueOf<R[K]> };\n type E = ErrValueOf<R[keyof R]>;\n\n const out: Partial<Out> = {};\n\n for (const key of Object.keys(record) as Array<keyof R>) {\n const result = record[key];\n if (!result) continue;\n if (result.isOk()) {\n out[key] = result.value as Out[typeof key];\n continue;\n }\n if (result.isErr()) return result as unknown as Result<Out, E>;\n throw new InvalidResultStateError('sequenceRecord');\n }\n\n return ok<Out, E>(out as Out);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport type { Awaitable } from './pipeable';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput =\n | Promise<Result<any, any>>\n | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Async version of collectFirstOk.\n *\n * - Takes either already started Promises or \"Thunks\" (`() => Awaitable<Result<...>>`).\n * - Processes inputs strictly sequentially (like `for ... of` + `await`).\n * - Returns the first `Ok` and collects all errors if no `Ok` is found.\n */\nexport async function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n const errors: Array<ErrValueOfInput<Inputs[number]>> = [];\n\n for (const input of inputs) {\n try {\n const result = await (typeof input === 'function' ? input() : input);\n if (result.isOk()) {\n return ok<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>(\n result.value as OkValueOfInput<Inputs[number]>\n );\n }\n if (result.isErr()) {\n errors.push(result.error as ErrValueOfInput<Inputs[number]>);\n continue;\n }\n throw new InvalidResultStateError('collectFirstOkAsync');\n } catch (error) {\n // If the Promise itself rejects, we treat it as an Error\n errors.push(error as ErrValueOfInput<Inputs[number]>);\n }\n }\n\n return err<ErrValueOfInput<Inputs[number]>[], OkValueOfInput<Inputs[number]>>(errors);\n}\n","import type { Awaitable } from './pipeable';\nimport type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Parallel version of `collectFirstOkAsync`.\n *\n * - Starts all inputs immediately (Promises or Thunks).\n * - Returns the first `Ok` as soon as it is available.\n * - If no `Ok` is found, returns an `Err` with all error values (in input order).\n * - Rejections are treated as `ErrValue` (`caught as ErrValue`).\n * - If multiple inputs provide an `Ok`, the one that completes first wins.\n * In case of simultaneous completion, the first observed result wins.\n * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.\n */\nexport async function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n type OkValue = OkValueOfInput<Inputs[number]>;\n type ErrValue = ErrValueOfInput<Inputs[number]>;\n\n if (inputs.length === 0) {\n return err<ErrValue[], OkValue>([]);\n }\n\n const started = inputs.map((input) =>\n typeof input === 'function' ? Promise.resolve().then(input) : input\n );\n\n const firstOk = new Promise<Result<OkValue, ErrValue[]>>((resolve) => {\n for (const promise of started) {\n promise\n .then((result) => {\n if (result.isOk()) {\n resolve(ok<OkValue, ErrValue[]>(result.value as OkValue));\n }\n })\n .catch(() => {\n // Ignored here; handled in allSettled below.\n });\n }\n });\n\n const allErrors = Promise.allSettled(started).then((settled) => {\n const errors: ErrValue[] = [];\n for (const entry of settled) {\n if (entry.status === 'fulfilled') {\n const result = entry.value;\n if (result.isErr()) {\n errors.push(result.error as ErrValue);\n } else if (!result.isOk()) {\n errors.push(new InvalidResultStateError('collectFirstOkParallelAsync') as ErrValue);\n }\n } else {\n errors.push(entry.reason as ErrValue);\n }\n }\n return err<ErrValue[], OkValue>(errors);\n });\n\n return Promise.race([firstOk, allErrors]);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines a list of Results.\n * Return Ok(values) only if all are Ok, otherwise Err([errors]).\n */\nexport function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Result<T[], E[]> {\n const values: T[] = [];\n const errors: E[] = [];\n\n for (const result of results) {\n if (result.isOk()) {\n values.push(result.value);\n continue;\n }\n if (result.isErr()) {\n errors.push(result.error);\n continue;\n }\n throw new InvalidResultStateError('collectAllErrors');\n }\n\n return errors.length === 0 ? ok(values) : err<E[], T[]>(errors);\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Partitions Results into Ok values and Err errors.\n */\nexport function partition<const Results extends readonly Result<any, any>[]>(\n results: Results\n): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>] {\n const oks: Array<OkValueOf<Results[number]>> = [];\n const errs: Array<ErrValueOf<Results[number]>> = [];\n\n for (const result of results) {\n if (result.isOk()) {\n oks.push(result.value as OkValueOf<Results[number]>);\n continue;\n }\n if (result.isErr()) {\n errs.push(result.error as ErrValueOf<Results[number]>);\n continue;\n }\n throw new InvalidResultStateError('partition');\n }\n\n return [oks, errs];\n}\n","import type { Result } from './result';\n\n/**\n * Flattens a nested Result.\n * Result<Result<T, E>, E> → Result<T, E>\n * Corresponds to Rust `flatten`.\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n if (result.isOk()) {\n return result.value;\n }\n return result as unknown as Result<T, E>;\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to a Promise.\n * Ok → resolve(value), Err → reject(error)\n */\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n if (result.isOk()) {\n return Promise.resolve(result.value);\n }\n if (result.isErr()) return Promise.reject(result.error);\n throw new InvalidResultStateError('toPromise');\n}\n","import type { Result } from './result';\n\n/**\n * Converts a Result to `T | null`.\n * Ok → value, Err → null\n */\nexport function toNullable<T, E>(result: Result<T, E>): T | null {\n if (result.isOk()) return result.value;\n return null;\n}\n","import type { Ok, Result } from './result';\n\n/**\n * Checks if a Result is Ok.\n * Pure function alternative to the instance method.\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T, E> {\n return result.isOk();\n}\n","import type { Err, Result } from './result';\n\n/**\n * Checks if a Result is Err.\n * Pure function alternative to the instance method.\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<T, E> {\n return result.isErr();\n}\n","import type { Result } from './result';\n\n/**\n * Checks if the Result contains a specific value.\n * Corresponds to Rust `contains`.\n */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n if (!result.isOk()) return false;\n return result.value === value;\n}\n","import type { Result } from './result';\n\n/**\n * Checks if the Result contains a specific error.\n * Analogous to `contains` for the Err case.\n */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n if (!result.isErr()) return false;\n return result.error === error;\n}\n"],"mappings":"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"}