npm - @shirudo/result - Versions diffs - 0.0.1 → 0.0.3 - Mend

@shirudo/result 0.0.1 → 0.0.3

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 (10) hide show

package/dist/index.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.mjs","names":["ret: any","#error","#matched","#value","#makeErr","#resolved","#result","#errCases","#okHandler","#state","fromNullableFn","fromPromiseFn","toPromiseFn","toNullableFn","input: unknown","step: IteratorResult<Result<any, any>, any>","mapErr","right","left","errors: Array<AE \| BE>","values: Array<OkValueOf<Results[number]>>","out: Partial<Out>","errors: E[]","errors: Array<ErrValueOfInput<Inputs[number]>>","errorsByIndex: Array<ErrValue \| typeof UNSET>","errors: ErrValue[]","values: Array<OkValueOf<Results[number]>>","errors: Array<ErrValueOf<Results[number]>>","oks: Array<OkValueOf<Results[number]>>","errs: Array<ErrValueOf<Results[number]>>"],"sources":["../src/pipeable.ts","../src/utils/isResult.ts","../src/matcher.ts","../src/conversions/fromNullable.ts","../src/conversions/fromPromise.ts","../src/conversions/try.ts","../src/conversions/toPromise.ts","../src/conversions/toNullable.ts","../src/result.ts","../src/gen.ts","../src/operators/map.ts","../src/operators/mapErr.ts","../src/operators/mapBoth.ts","../src/operators/flatMap.ts","../src/operators/tap.ts","../src/operators/filter.ts","../src/operators/fold.ts","../src/operators/tryCatch.ts","../src/operators/tryMap.ts","../src/operators/recover.ts","../src/operators-async/mapAsync.ts","../src/operators-async/mapErrAsync.ts","../src/operators-async/flatMapAsync.ts","../src/operators-async/tapAsync.ts","../src/operators-async/filterAsync.ts","../src/operators-async/foldAsync.ts","../src/operators-async/tryCatchAsync.ts","../src/operators-async/tryMapAsync.ts","../src/unwrap/unwrap.ts","../src/unwrap/unwrapOr.ts","../src/unwrap/unwrapOrElse.ts","../src/unwrap/unwrapOrDefault.ts","../src/unwrap/unwrapOrThrow.ts","../src/unwrap/unwrapErr.ts","../src/unwrap/expectResult.ts","../src/unwrap/expectErr.ts","../src/combinators/and.ts","../src/combinators/or.ts","../src/combinators/orElse.ts","../src/combinators/mapOr.ts","../src/combinators/mapOrElse.ts","../src/combinators/zip.ts","../src/combinators/swap.ts","../src/collections/sequence.ts","../src/collections/sequenceRecord.ts","../src/collections/collectFirstOk.ts","../src/collections/collectFirstOkAsync.ts","../src/collections/collectFirstOkRaceAsync.ts","../src/collections/collectAllErrors.ts","../src/collections/partition.ts","../src/collections/flatten.ts","../src/utils/isOk.ts","../src/utils/isErr.ts","../src/utils/contains.ts","../src/utils/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(): this;\n pipe<B>(ab: UnaryFunction<this, B>): B;\n pipe<B, C>(ab: UnaryFunction<this, B>, bc: UnaryFunction<B, C>): C;\n pipe<B, C, D>(ab: UnaryFunction<this, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>): D;\n pipe<A, B, C, D, E>(\n this: A,\n ab: UnaryFunction<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, B>): Promise<Awaited<B>>;\n pipeAsync<A, B, C>(this: A, ab: UnaryFunction<this, B>, bc: UnaryFunction<Awaited<B>, C>): Promise<Awaited<C>>;\n pipeAsync<A, B, C, D>(\n this: A,\n ab: UnaryFunction<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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","import type { Result } from '../result';\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 any).isOk === 'function' &&\n 'isErr' in value &&\n typeof (value as any).isErr === 'function'\n );\n}\n","import type { Result } from './result';\nimport { isResult } from './utils/isResult';\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 any return type, e.g. string messages).\n \n - `.when(Ctor, handler)` matched via `instanceof`\n * - `.whenGuard(guard, handler)` matched via type guard\n * - `.run()` is only allowed once all error cases are handled (`E` is 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<any>, 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 any;\n\n if (this.#error instanceof ctor) {\n return new ErrorMatchBuilder(this.#error, true, handler(this.#error as InstanceType<C>)) as any;\n }\n\n return this as any;\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: any) => R2): R \| R2 {\n if (this.#matched) return this.#value as R;\n return handler(this.#error);\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\n/\n Matcher for `Result` errors that always returns a `Result`.\n \n Handlers may:\n * - return a `Result` (returned directly)\n * - return an error value (automatically wrapped to `Err(error)`)\n /\nexport class ErrMatchBuilder<T, E, OutT, OutE> {\n readonly #makeErr: ErrFactory;\n readonly #error: unknown;\n // Note: `any` is required here due to Result's invariance from type predicates\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 Error('Unreachable: Result is neither Ok nor Err');\n }\n\n when<C extends Ctor<any>, 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 // Already matched - just update the type\n return this as any;\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 // Cast needed: Result is invariant due to type predicates, but we know this is safe\n return new ErrMatchBuilder(this.#makeErr, this.#error, resolved as any) as any;\n }\n\n // Not matched yet - continue with narrowed type\n return this as any;\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 any;\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 // Cast needed: Result is invariant due to type predicates, but we know this is safe\n return new ErrMatchBuilder(this.#makeErr, this.#error, resolved as any) 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\ntype ErrCase =\n \| { readonly kind: 'ctor'; readonly ctor: Ctor<any>; readonly handler: (error: any) => unknown }\n \| { readonly kind: 'val'; readonly value: unknown; readonly handler: (error: any) => unknown };\n\ndeclare const HAS_OK: unique symbol;\ntype HasOk = { readonly [HAS_OK]: true };\ntype WithOk<T, E, R> = ResultMatchBuilder<T, E, R> & HasOk;\n\ntype IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : never;\n\ntype ExcludeIfLiteral<E, V> =\n IsUnion<V> extends true\n ? E\n : V extends string\n ? string extends V\n ? E\n : Exclude<E, V>\n : V extends number\n ? number extends V\n ? E\n : Exclude<E, V>\n : V extends boolean\n ? boolean extends V\n ? E\n : Exclude<E, V>\n : V extends bigint\n ? bigint extends V\n ? E\n : Exclude<E, V>\n : V extends symbol\n ? symbol extends V\n ? E\n : Exclude<E, V>\n : Exclude<E, V>;\n\n/\n Universal matcher for `Result` (Ok + Err in a single chain).\n \n - `.err(Ctor, handler)` matched via `instanceof`\n * - `.errVal(value, handler)` matched via `Object.is`\n * - `.ok(handler)` defines the success branch\n * - `.run()` is only allowed after `.ok()` is set\n \n Lazy: if the Result is `Ok`, Err cases are not evaluated in `.run()`.\n /\nexport class ResultMatchBuilder<T, E, R> {\n readonly #result: Result<T, E>;\n readonly #errCases: readonly ErrCase[];\n readonly #okHandler: ((value: T) => unknown) \| undefined;\n\n constructor(result: Result<T, E>, errCases: readonly ErrCase[] = [], okHandler?: (value: T) => unknown) {\n this.#result = result;\n this.#errCases = Object.freeze([...errCases]);\n this.#okHandler = okHandler;\n Object.freeze(this);\n }\n\n static fromResult<T, E>(result: Result<T, E>): ResultMatchBuilder<T, E, never> {\n return new ResultMatchBuilder(result);\n }\n\n err<C extends Ctor<any>, R1>(\n this: ResultMatchBuilder<T, E, R>,\n ctor: C,\n handler: (error: InstanceType<C>) => R1\n ): ResultMatchBuilder<T, Exclude<E, InstanceType<C>>, R \| R1>;\n err<C extends Ctor<any>, R1>(\n this: WithOk<T, E, R>,\n ctor: C,\n handler: (error: InstanceType<C>) => R1\n ): WithOk<T, Exclude<E, InstanceType<C>>, R \| R1>;\n err<C extends Ctor<any>, R1>(ctor: C, handler: (error: InstanceType<C>) => R1): unknown {\n const next = new ResultMatchBuilder(\n this.#result as unknown as Result<T, Exclude<E, InstanceType<C>>>,\n [...this.#errCases, { kind: 'ctor', ctor, handler } satisfies ErrCase],\n this.#okHandler\n );\n return next as unknown;\n }\n\n errVal<const V, R1>(\n this: ResultMatchBuilder<T, E, R>,\n value: V,\n handler: (error: V) => R1\n ): ResultMatchBuilder<T, ExcludeIfLiteral<E, V>, R \| R1>;\n errVal<const V, R1>(\n this: WithOk<T, E, R>,\n value: V,\n handler: (error: V) => R1\n ): WithOk<T, ExcludeIfLiteral<E, V>, R \| R1>;\n errVal<const V, R1>(value: V, handler: (error: V) => R1): unknown {\n const next = new ResultMatchBuilder(\n this.#result as unknown as Result<T, ExcludeIfLiteral<E, V>>,\n [...this.#errCases, { kind: 'val', value, handler } satisfies ErrCase],\n this.#okHandler\n );\n return next as unknown;\n }\n\n ok<R1>(handler: (value: T) => R1): WithOk<T, E, R \| R1> {\n const next = new ResultMatchBuilder(this.#result, this.#errCases, handler);\n return next as unknown as WithOk<T, E, R \| R1>;\n }\n\n run(this: WithOk<T, E, R>): R {\n const result = this.#result;\n\n if (result.isOk()) {\n const okHandler = this.#okHandler as ((value: T) => R) \| undefined;\n if (!okHandler) throw new Error('ResultMatchBuilder.run() requires an ok() handler.');\n return okHandler(result.value);\n }\n\n if (result.isErr()) {\n const error = result.error as E;\n\n for (const c of this.#errCases) {\n if (c.kind === 'ctor') {\n if ((error as any) instanceof c.ctor) return c.handler(error) as R;\n continue;\n }\n if (Object.is(error, c.value)) return c.handler(error) as R;\n }\n\n throw error;\n }\n\n throw new Error('Unreachable: Result is neither Ok nor Err');\n }\n}\n","import { Result } from '../result';\n\n/\n Converts `null \| undefined` to `Err`, everything else to `Ok`.\n * \n * Type Safety: The type assertion `as NonNullable<T>` is safe,\n * as the runtime check guarantees that the value is not null/undefined.\n * \n * @param value The value to check\n * @param error The error to use if value is null/undefined\n * @returns An Ok Result with the NonNullable value, or an Err Result with the error\n * \n * @example\n * ```ts\n * fromNullable(user, 'User not found')\n * // Ok(user) or Err('User not found')\n * ```\n /\nexport function fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E> {\n if (value === null \|\| value === undefined) {\n return Result.err<E, NonNullable<T>>(error);\n }\n return Result.ok<NonNullable<T>, E>(value as NonNullable<T>);\n}\n\n","import { Result } from '../result';\n\n/\n Converts a Promise to a Result-Promise.\n * Exceptions are converted to Err.\n * \n * @param promise The Promise to convert\n * @param errorMapper Optional function to map errors to a specific type\n * @returns A Promise that resolves to an Ok Result with the value, or an Err Result with the error\n * \n * @example\n * ```ts\n * const result = await fromPromise(fetch('/api/user'));\n * // Ok(response) or Err(error)\n * \n * // With custom error mapper\n * const result = await fromPromise(\n * fetch('/api/user'),\n * (e) => `Network error: ${e}`\n * );\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 Result.ok<T, E>(value);\n } catch (error) {\n try {\n return Result.err(errorMapper ? errorMapper(error) : error as E);\n } catch (mapperError) {\n // If the errorMapper itself throws an error, use that one\n return Result.err(mapperError as E);\n }\n }\n}","import { Result } from '../result';\n\n/\n Executes a function and catches exceptions.\n * \n * @param fn The function to execute\n * @returns An Ok Result with the return value, or an Err Result with the caught exception\n * \n * @example\n * ```ts\n * const result = tryFn(() => JSON.parse(input));\n * // Ok(parsed) or Err(SyntaxError)\n * ```\n /\nexport function tryFn<T>(fn: () => T): Result<T, unknown> {\n try {\n return Result.ok(fn());\n } catch (error) {\n return Result.err(error);\n }\n}","import type { Result } from '../result';\n\n/\n Converts a Result to a Promise.\n * Ok → resolves with the value, Err → rejects with the error\n * \n * @param result The Result to convert\n * @returns A Promise that resolves with the value if Ok, or rejects with the error if Err\n * \n * @example\n * ```ts\n * const result = ok(42);\n * const promise = toPromise(result);\n * const value = await promise; // 42\n * ```\n /\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n if (result.isOk()) {\n return Promise.resolve(result.value!);\n }\n return Promise.reject(result.error!);\n}\n","import type { Result } from '../result';\n\n/\n Converts a Result to `T \| null`.\n * Ok → returns the value, Err → returns null\n * \n * @param result The Result to convert\n * @returns The value if Ok, or null if Err\n * \n * @example\n * ```ts\n * const result = ok(42);\n * const value = toNullable(result); // 42\n * \n * const errResult = err('error');\n * const nullValue = toNullable(errResult); // null\n * ```\n /\nexport function toNullable<T, E>(result: Result<T, E>): T \| null {\n if (result.isOk()) {\n return result.value!;\n }\n return null;\n}\n","import { Pipeable } from './pipeable';\nimport { ErrMatchBuilder, ErrorMatchBuilder, ResultMatchBuilder } from './matcher';\nimport { fromNullable as fromNullableFn } from './conversions/fromNullable';\nimport { fromPromise as fromPromiseFn } from './conversions/fromPromise';\nimport { tryFn } from './conversions/try';\nimport { toPromise as toPromiseFn } from './conversions/toPromise';\nimport { toNullable as toNullableFn } from './conversions/toNullable';\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. The Result Class ---\n\nexport type Ok<T> = { readonly _tag: 'Ok'; readonly value: T };\nexport type Err<E> = { readonly _tag: 'Err'; readonly error: E };\nexport type ResultType<T, E> = Ok<T> \| Err<E>;\n\nexport class Result<T, E> extends Pipeable {\n readonly #state: ResultType<T, E>;\n\n private constructor(state: ResultType<T, E>) {\n super();\n Object.freeze(state);\n this.#state = state;\n Object.freeze(this);\n }\n\n /\n Creates an Ok Result with the given value.\n * \n * Note: `null` and `undefined` are allowed as values.\n * If you want to convert `null`/`undefined` to an Err, use `fromNullable()`.\n * \n * @param value The value for the Ok Result\n * @returns An Ok Result with the given value\n * \n * @example\n * ```ts\n * const result = Result.ok(42);\n * const nullResult = Result.ok(null); // Allowed!\n * ```\n /\n static ok<T, E = never>(value: T): Result<T, E> {\n return new Result<T, E>({ _tag: 'Ok', value });\n }\n\n /\n Creates an Err Result with the given error.\n * \n * Note: `null` and `undefined` are allowed as errors.\n * \n * @param error The error for the Err Result\n * @returns An Err Result with the given error\n * \n * @example\n * ```ts\n * const result = Result.err('error message');\n * const nullError = Result.err(null); // Allowed!\n * ```\n /\n static err<E, T = never>(error: E): Result<T, E> {\n return new Result<T, E>({ _tag: 'Err', error });\n }\n\n /\n Converts `null \| undefined` to `Err`, everything else to `Ok`.\n * \n * Type Safety: The type assertion `as NonNullable<T>` is safe,\n * as the runtime check guarantees that the value is not null/undefined.\n * \n * @param value The value to check\n * @param error The error to use if value is null/undefined\n * @returns An Ok Result with the NonNullable value, or an Err Result with the error\n * \n * @example\n * ```ts\n * Result.fromNullable(user, 'User not found')\n * // Ok(user) or Err('User not found')\n * ```\n /\n static fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E> {\n return fromNullableFn(value, error);\n }\n\n /\n Converts a Promise to a Result-Promise.\n * Exceptions are converted to Err.\n * \n * This static method delegates to the standalone `fromPromise()` function.\n * \n * @example\n * ```ts\n * const result = await Result.fromPromise(fetch('/api/user'));\n * // Ok(response) or Err(error)\n * \n * // With custom error mapper\n * const result = await Result.fromPromise(\n * fetch('/api/user'),\n * (e) => `Network error: ${e}`\n * );\n * ```\n /\n static fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;\n static fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;\n static fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>> {\n return fromPromiseFn(promise, errorMapper);\n }\n\n /\n Executes a function and catches exceptions.\n * \n * @example\n * ```ts\n * const result = Result.try(() => JSON.parse(input));\n * // Ok(parsed) or Err(SyntaxError)\n * ```\n /\n static try<T>(fn: () => T): Result<T, unknown> {\n return tryFn(fn);\n }\n\n // Basic helpers for internal access in operators\n /\n Checks if the Result is Ok.\n * \n * @returns `true` if the Result is Ok (and narrows the type)\n * \n * @example\n * ```ts\n * if (result.isOk()) {\n * const value: T = result.value; // TypeScript knows that value is defined\n * }\n * ```\n /\n isOk(): this is Result<T, E> & { readonly value: T; readonly error: undefined } {\n return this.#state._tag === 'Ok';\n }\n\n /\n Checks if the Result is Err.\n * \n * @returns `true` if the Result is Err (and narrows the type)\n * \n * @example\n * ```ts\n * if (result.isErr()) {\n * const error: E = result.error; // TypeScript knows that error is defined\n * }\n * ```\n /\n isErr(): this is Result<T, E> & { readonly value: undefined; readonly error: E } {\n return this.#state._tag === 'Err';\n }\n\n get value(): T \| undefined {\n return this.#state._tag === 'Ok' ? this.#state.value : undefined;\n }\n\n get error(): E \| undefined {\n return this.#state._tag === 'Err' ? this.#state.error : undefined;\n }\n\n /\n Returns the value, guaranteed to be defined after `isOk()` check.\n * This method provides better type narrowing than the `value` getter.\n * \n * ⚠️ Warning: This method throws an Error if called on an Err result.\n * Use this method only after a type guard (`if (result.isOk())`).\n * For a safer alternative with a custom message, use `expect()`.\n * \n * @throws {Error} If called on an Err result\n * \n * @example\n * ```ts\n * if (result.isOk()) {\n * const value = result.unwrap(); // Type is T, not T \| undefined\n * }\n * ```\n /\n unwrap(): T {\n if (this.#state._tag === 'Ok') {\n return this.#state.value;\n }\n // Safe string conversion for error messages\n const errorStr = (() => {\n try {\n const error = this.#state.error;\n if (error === null) return 'null';\n if (error === undefined) return 'undefined';\n if (typeof error === 'string') return error;\n if (error instanceof Error) return error.message;\n if (typeof error === 'object' && 'toString' in error) {\n try {\n return String(error);\n } catch {\n return '[unstringifiable error]';\n }\n }\n return String(error);\n } catch {\n return '[unstringifiable error]';\n }\n })();\n throw new Error(`Called unwrap() on Err: ${errorStr}`);\n }\n\n /\n Returns the error, guaranteed to be defined after `isErr()` check.\n * This method provides better type narrowing than the `error` getter.\n * \n * ⚠️ Warning: This method throws an Error if called on an Ok result.\n * Use this method only after a type guard (`if (result.isErr())`).\n * For a safer alternative with a custom message, use `expectErr()`.\n * \n * @throws {Error} If called on an Ok result\n * \n * @example\n * ```ts\n * if (result.isErr()) {\n * const error = result.unwrapErr(); // Type is E, not E \| undefined\n * }\n * ```\n /\n unwrapErr(): E {\n if (this.#state._tag === 'Err') {\n return this.#state.error;\n }\n // Safe string conversion for error messages\n const valueStr = (() => {\n try {\n const value = this.#state.value;\n if (value === null) return 'null';\n if (value === undefined) return 'undefined';\n if (typeof value === 'string') return value;\n if (value instanceof Error) return value.message;\n if (typeof value === 'object' && 'toString' in value) {\n try {\n return String(value);\n } catch {\n return '[unstringifiable value]';\n }\n }\n return String(value);\n } catch {\n return '[unstringifiable value]';\n }\n })();\n throw new Error(`Called unwrapErr() on Ok: ${valueStr}`);\n }\n\n /\n Returns the value with a custom error message if the result is Err.\n * Similar to `unwrap()`, but allows you to provide a custom error message.\n * \n * ⚠️ Warning: This method throws an Error if called on an Err result.\n * Use this method only if you are sure the Result is Ok,\n * or if you need a meaningful error message.\n * \n * @param message Custom error message to throw if result is Err\n * @returns The value if result is Ok\n * @throws {Error} If called on an Err result with the provided message\n * \n * @example\n * ```ts\n * const result = fetchUser(id);\n * const user = result.expect('User should exist'); // Throws with custom message if Err\n * ```\n /\n expect(message: string): T {\n if (this.#state._tag === 'Ok') {\n return this.#state.value;\n }\n throw new Error(message);\n }\n\n /\n Returns the error with a custom error message if the result is Ok.\n * Similar to `unwrapErr()`, but allows you to provide a custom error message.\n * \n * ⚠️ Warning: This method throws an Error if called on an Ok result.\n * Use this method only if you are sure the Result is Err,\n * or if you need a meaningful error message.\n * \n * @param message Custom error message to throw if result is Ok\n * @returns The error if result is Err\n * @throws {Error} If called on an Ok result with the provided message\n * \n * @example\n * ```ts\n * const result = validateInput(input);\n * if (result.isErr()) {\n * const error = result.expectErr('Validation should have failed'); // Throws if Ok\n * }\n * ```\n /\n expectErr(message: string): E {\n if (this.#state._tag === 'Err') {\n return this.#state.error;\n }\n throw new Error(message);\n }\n\n unwrapOr<D = T>(defaultValue: D): T \| D {\n return this.#state._tag === 'Ok' ? this.#state.value : defaultValue;\n }\n\n /\n Converts the Result to a Promise.\n * Ok → resolves with the value, Err → rejects with the error\n * \n * This instance method delegates to the standalone `toPromise()` function.\n * \n * @returns A Promise that resolves with the value if Ok, or rejects with the error if Err\n * \n * @example\n * ```ts\n * const result = ok(42);\n * const promise = result.toPromise();\n * const value = await promise; // 42\n * \n * const errResult = err('error');\n * try {\n * await errResult.toPromise();\n * } catch (error) {\n * console.log(error); // 'error'\n * }\n * ```\n /\n toPromise(): Promise<T> {\n return toPromiseFn(this);\n }\n\n /\n Converts the Result to `T \| null`.\n * Ok → returns the value, Err → returns null\n * \n * This instance method delegates to the standalone `toNullable()` function.\n * \n * @returns The value if Ok, or null if Err\n * \n * @example\n * ```ts\n * const result = ok(42);\n * const value = result.toNullable(); // 42\n * \n * const errResult = err('error');\n * const nullValue = errResult.toNullable(); // null\n * ```\n /\n toNullable(): T \| null {\n return toNullableFn(this);\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<Result<T, E>, T, unknown> {\n return (yield this) as T;\n }\n\n /*\n Universal pattern matcher for Ok + Err cases.\n * \n * Use this to exhaustively match on both success and error cases with type-based\n * and value-based pattern matching.\n * \n * @example\n * ```ts\n * const message = result\n * .match()\n * .err(NetworkError, e => `Network: ${e.message}`)\n * .err(ValidationError, e => `Validation: ${e.message}`)\n * .ok(val => `Success: ${val}`)\n * .run();\n * ```\n /\n match(): ResultMatchBuilder<T, E, never> {\n return ResultMatchBuilder.fromResult(this);\n }\n\n /\n Matches on the Err value via `.when(...)` chain.\n \n Note: For type safety reasons, `.matchErr()` can only be called on a Result that has already been narrowed to `Err`,\n * e.g., inside `if (result.isErr()) { ... }`.\n * \n * @example\n * ```ts\n * if (result.isErr()) {\n * const message = result\n * .matchErr()\n * .when(IOError, () => 'IO error')\n * .when(ParseError, () => 'Parse error')\n * .otherwise(e => `Other: ${e}`);\n * }\n * ```\n /\n matchErr(this: Result<T, E> & { readonly error: E }): ErrorMatchBuilder<E, never>;\n matchErr(this: Result<T, E>): never;\n matchErr(): unknown {\n if (this.isErr()) return new ErrorMatchBuilder(this.error);\n throw new Error('matchErr() can only be called on Err results. Use `if (result.isErr()) { ... }` first.');\n }\n\n /\n Matches on the Err value, but normalizes every branch to a `Result`:\n * - Handlers may return a `Result` (returned directly)\n * - or an error value (wrapped to `Err(error)`)\n /\n matchErrResult(): ErrMatchBuilder<T, E, never, never> {\n const makeErr = <Err>(error: Err) => Result.err<Err, never>(error);\n return ErrMatchBuilder.fromResult(this, makeErr);\n }\n\n /\n @deprecated Use `.match()` instead. Will be removed in next major version.\n /\n pattern(): ResultMatchBuilder<T, E, never> {\n return this.match();\n }\n\n /\n @deprecated Use `.match()` instead. Will be removed in next major version.\n /\n switch(): ResultMatchBuilder<T, E, never> {\n return this.match();\n }\n\n /\n Folds the Result into a single value by applying one of two functions.\n * \n * This is a direct method equivalent to the `match` pipe operator.\n * Use this when you want to handle both Ok and Err cases and return a single value.\n * \n * @param onOk Function to apply if the Result is Ok\n * @param onErr Function to apply if the Result is Err\n * @returns The result of applying the appropriate function\n * \n * @example\n * ```ts\n * const result = ok(42);\n * const message = result.fold(\n * val => `Success: ${val}`,\n * err => `Error: ${err}`\n * );\n * // message = \"Success: 42\"\n * ```\n * \n * @example\n * ```ts\n * // Works with discriminated unions\n * const result: Result<string, number> = err(404);\n * const response = result.fold(\n * data => ({ success: true as const, data }),\n * code => ({ success: false as const, code })\n * );\n * // response: { success: true; data: string } \| { success: false; code: number }\n * ```\n /\n fold<R1, R2 = R1>(onOk: (value: T) => R1, onErr: (error: E) => R2): R1 \| R2 {\n if (this.isOk()) {\n return onOk(this.value);\n }\n if (this.isErr()) {\n return onErr(this.error);\n }\n throw new Error('Unreachable: Result is neither Ok nor Err');\n }\n\n /\n Returns the Result as a discriminated union (`{ _tag: 'Ok', value } \| { _tag: 'Err', error }`).\n * Useful for libraries like `ts-pattern` that match on plain object unions.\n /\n toUnion(): ResultType<T, E> {\n return this.#state;\n }\n\n /\n Serializes the Result into a simple object format.\n * Preserves the original types.\n /\n serialize(): { isSuccess: boolean; data?: T; error?: E } {\n if (this.#state._tag === 'Ok') return { isSuccess: true, data: this.#state.value };\n return { isSuccess: false, error: this.#state.error };\n }\n\n /\n Serializes the Result into a user-friendly format.\n * Converts errors to readable strings.\n /\n toUserFriendly(): { isSuccess: boolean; data?: T; error?: string } {\n if (this.#state._tag === 'Ok') return { isSuccess: true, data: this.#state.value };\n\n const error = this.#state.error;\n const toSafeString = (value: unknown): string => {\n try {\n return String(value);\n } catch {\n return '[Unstringifiable error]';\n }\n };\n const errorMessage = (() => {\n if (error && typeof error === 'object' && 'message' in error) {\n const message = (error as { message?: unknown }).message;\n return typeof message === 'string' ? message : toSafeString(error);\n }\n return toSafeString(error);\n })();\n\n return { isSuccess: false, error: errorMessage };\n }\n\n}\n\n// Helper constructors\nexport const ok = Result.ok;\nexport const err = Result.err;\n\n/\n Helper for conditional Result creation.\n * Avoids type inference issues with ternary operators.\n * \n * @example\n * ```ts\n * const result = okIf(value > 5, value, 'too small');\n * // instead of: value > 5 ? ok(value) : err('too small')\n * ```\n /\nexport function okIf<T, E>(\n condition: boolean,\n okValue: T,\n errValue: E\n): Result<T, E> {\n return condition ? ok(okValue) : err(errValue);\n}\n\n/\n Helper for conditional Result creation with lazy evaluation.\n * Evaluates values only when they are needed.\n * \n * @example\n * ```ts\n * const result = okIfLazy(\n * value > 5,\n * () => expensiveComputation(value),\n * () => 'too small'\n * );\n * ```\n /\nexport function okIfLazy<T, E>(\n condition: boolean,\n okFn: () => T,\n errFn: () => E\n): Result<T, E> {\n return condition ? ok(okFn()) : err(errFn());\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { isResult } from './utils/isResult';\n\ntype AnyGenerator = Generator<any, any, unknown> \| AsyncGenerator<any, any, unknown>;\n\ntype YieldOf<G> = G extends Generator<infer Y, any, any>\n ? Y\n : G extends AsyncGenerator<infer Y, any, any>\n ? Y\n : never;\n\ntype ReturnOf<G> = G extends Generator<any, infer R, any>\n ? R\n : G extends AsyncGenerator<any, infer R, any>\n ? R\n : never;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype ErrorOfGenerator<G> = ErrorOfYield<YieldOf<G>>;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturnOf<G> = Awaited<ReturnOf<G>>;\ntype OkOfReturn<G> = AwaitedReturnOf<G> extends Result<infer T, any> ? T : AwaitedReturnOf<G>;\ntype ErrOfReturn<G> = AwaitedReturnOf<G> 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 G extends AnyGenerator>(\n makeGenerator: () => G\n): Promise<Result<OkOfReturn<G>, ErrorOfGenerator<G> \| ErrOfReturn<G>>>;\nexport async function task<const G extends AnyGenerator, EThrown>(\n makeGenerator: () => G,\n onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<G>, ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown>>;\nexport async function task<const G extends AnyGenerator, EThrown>(\n makeGenerator: () => G,\n onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<G>, ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown>> {\n const iterator = makeGenerator();\n let input: unknown = undefined;\n\n while (true) {\n let step: IteratorResult<Result<any, any>, any>;\n try {\n step = await (iterator as any).next(input);\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown, OkOfReturn<G>>(onThrow(caught));\n }\n\n if (step.done) {\n try {\n const awaited = await (step.value as any);\n if (isResult(awaited)) {\n return awaited as Result<OkOfReturn<G>, ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown>;\n }\n return ok<OkOfReturn<G>, ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown>(awaited);\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown, OkOfReturn<G>>(onThrow(caught));\n }\n }\n\n const yielded = step.value as unknown;\n if (!isResult(yielded)) {\n throw new TypeError('task() expected yielded values to be Result. Use `yield` on a Result.');\n }\n\n if (yielded.isOk()) {\n input = yielded.value;\n continue;\n }\n\n if (yielded.isErr()) {\n try {\n if (typeof (iterator as any).return === 'function') {\n await (iterator as any).return(undefined);\n }\n } catch (caught) {\n if (!onThrow) throw caught;\n return err<ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown, OkOfReturn<G>>(onThrow(caught));\n }\n\n return yielded as Result<OkOfReturn<G>, ErrorOfGenerator<G> \| ErrOfReturn<G> \| EThrown>;\n }\n\n throw new Error('Unreachable: Result is neither Ok nor Err');\n }\n}\n\nexport const gen = task;\n","import type { Result } from '../result';\nimport { ok } from '../result';\n\n/*\n Transforms the value (Ok case).\n * Equivalent 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 * Equivalent 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';\n\n/\n Transforms both the Ok value and the Err error.\n * Equivalent 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 Error('Unreachable: Result is neither Ok nor Err');\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 * Equivalent to Rust `and_then` or JS `flatMap`.\n /\nexport function flatMap<T, E, U, E2 = E>(project: (value: T) => Result<U, E2>) {\n return (source: Result<T, E>): Result<U, E \| E2> => {\n if (source.isOk()) {\n return project(source.value) as unknown as Result<U, E \| E2>;\n }\n return source as unknown as Result<U, E \| E2>;\n };\n}\n","import type { Result } from '../result';\n\n/\n Executes a side effect (logging, debugging) without changing the Result.\n * Equivalent to Rust `inspect` / `inspect_err`.\n /\nexport function tap<T, E>(observer: { ok?: (val: T) => void; err?: (e: E) => void }) {\n return <SourceT extends T, SourceE extends E>(source: Result<SourceT, SourceE>): Result<SourceT, SourceE> => {\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 predicate. If false, the Result becomes Err.\n * Partially equivalent to Rust `filter`.\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n\n/\n @deprecated Use `fold` instead. Will be removed in next major version.\n /\nexport const match = fold;\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 * Equivalent to Rust `Result::from` for fallible operations.\n /\nexport function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E) {\n return <SourceT, SourceE>(source: Result<SourceT, SourceE>): Result<T \| SourceT, E \| SourceE> => {\n // Cast needed: Result is invariant, but we know this is safe at runtime\n if (source.isErr()) return source as unknown as Result<T \| SourceT, E \| SourceE>;\n\n try {\n return ok(fn()) as unknown as Result<T \| SourceT, E \| SourceE>;\n } catch (error) {\n return err(errorMapper ? errorMapper(error) : (error as E)) as unknown as Result<T \| SourceT, E \| SourceE>;\n }\n };\n}\n","import type { Result } from '../result';\nimport { ok, err } from '../result';\n\n/\n Like `map`, but catches exceptions and turns them into 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 Error('Unreachable: Result is neither Ok nor Err');\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 } from '../result';\n\n/\n Recover: turns Err into Ok(defaultValue).\n * Result is guaranteed Ok → error type becomes `never`.\n /\nexport function recover<T, E, D = T>(defaultValue: D) {\n return (source: Result<T, E>): Result<T \| D, never> => {\n if (source.isOk()) return source as unknown as Result<T \| D, never>;\n if (source.isErr()) return ok(defaultValue) as unknown as Result<T \| D, never>;\n throw new Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n\n/\n Like `recover`, but computes the default value from the error.\n /\nexport function recoverWith<T, E, D = T>(fn: (error: E) => D) {\n return (source: Result<T, E>): Result<T \| D, never> => {\n if (source.isOk()) return source as unknown as Result<T \| D, never>;\n if (source.isErr()) return ok(fn(source.error)) as unknown as Result<T \| D, never>;\n throw new Error('Unreachable: Result is neither Ok nor Err');\n };\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<Awaited<U>, E>> => {\n if (source.isOk()) {\n return ok(await project(source.value));\n }\n return source as unknown as Result<Awaited<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 * Allows different error types in the projected Result.\n /\nexport function flatMapAsync<T, E, U, E2 = E>(project: (value: T) => Promise<Result<U, E2>>) {\n return async (source: Result<T, E>): Promise<Result<U, E \| E2>> => {\n if (source.isOk()) {\n return (await project(source.value)) as unknown as Result<U, E \| E2>;\n }\n return source as unknown as Result<U, E \| E2>;\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 <SourceT extends T, SourceE extends E>(source: Result<SourceT, SourceE>): Promise<Result<SourceT, SourceE>> => {\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n\n/\n @deprecated Use `foldAsync` instead. Will be removed in next major version.\n /\nexport const matchAsync = foldAsync;\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 <SourceT, SourceE>(source: Result<SourceT, SourceE>): Promise<Result<T, E \| SourceE>> => {\n if (source.isErr()) return source as unknown as Result<T, E \| SourceE>;\n\n try {\n return ok<T, E \| SourceE>(await fn());\n } catch (error) {\n return err(errorMapper ? errorMapper(error) : error as E);\n }\n };\n}\n","import type { Result } from '../result';\nimport { ok, err } from '../result';\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 Error('Unreachable: Result is neither Ok nor Err');\n } catch (error) {\n return err<E \| F, U>(errorMapper ? errorMapper(error) : error as F);\n }\n };\n}\n","import type { Result } from '../result';\n\n/\n Returns the value or throws an Error.\n * Equivalent 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 Error(`Called unwrap() on Err: ${String(result.error)}`);\n throw new Error('Unreachable: Result is neither Ok nor Err');\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, D = T>(result: Result<T, E>, defaultValue: D): T \| D {\n if (result.isOk()) return result.value;\n return defaultValue;\n}\n","import type { Result } from '../result';\n\n/\n Returns the value or computes a default value with a function.\n * Equivalent to Rust `unwrap_or_else`.\n /\nexport function unwrapOrElse<T, E, D = T>(result: Result<T, E>, fn: (error: E) => D): T \| D {\n if (result.isOk()) return result.value;\n if (result.isErr()) return fn(result.error);\n throw new Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from '../result';\nimport { unwrapOr } from './unwrapOr';\n\n/\n Alias for `unwrapOr`.\n * Equivalent to Rust `unwrap_or_default` (with an explicit default value).\n /\nexport function unwrapOrDefault<T, E, D = T>(result: Result<T, E>, defaultValue: D): T \| D {\n return unwrapOr(result, defaultValue);\n}\n","import type { Result } from '../result';\n\n/\n Returns the value or throws the original Err value (not wrapped).\n * Useful to keep `Error` instances with 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 Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from '../result';\n\n/\n Returns the error or throws an Error.\n * Equivalent 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 Error(`Called unwrapErr() on Ok: ${String(result.value)}`);\n throw new Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from '../result';\n\n/\n Returns the value or throws an Error with a custom message.\n * Equivalent 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 Error(message);\n}\n","import type { Result } from '../result';\n\n/\n Returns the error or throws an Error with a custom message.\n * Equivalent 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 Error(message);\n}\n","import type { Result } from '../result';\n\n/\n Combines two Results. Returns the second only if the first is Ok.\n * Equivalent 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}\n","import type { Result } from '../result';\n\n/\n Fallback to another Result when the first is Err.\n * Equivalent to Rust `or`.\n /\nexport function or<T, E, T2 = T, E2 = E>(result: Result<T, E>, other: Result<T2, E2>): Result<T \| T2, E2> {\n return result.isOk() ? (result as unknown as Result<T \| T2, E2>) : (other as unknown as Result<T \| T2, E2>);\n}\n","import type { Result } from '../result';\n\n/\n Fallback using a function that returns a Result.\n * Equivalent to Rust `or_else`.\n /\nexport function orElse<T, E, T2 = T, E2 = E>(\n result: Result<T, E>,\n fn: (error: E) => Result<T2, E2>\n): Result<T \| T2, E2> {\n if (result.isOk()) return result as unknown as Result<T \| T2, E2>;\n if (result.isErr()) return fn(result.error) as unknown as Result<T \| T2, E2>;\n throw new Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from '../result';\n\n/\n Transforms the value or returns a default value.\n * Equivalent 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';\n\n/\n Transforms the value or computes a default value with a function.\n * Equivalent 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 Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from '../result';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\nimport { err, ok } from '../result';\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 Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from '../result';\nimport { ok } from '../result';\n\ntype ResultLike<T, E> = {\n isOk(): boolean;\n isErr(): boolean;\n readonly value: T \| undefined;\n readonly error: E \| undefined;\n};\n\ntype OkValueOf<R> = R extends ResultLike<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends ResultLike<any, infer E> ? E : never;\n\n/\n Combines a list of Results into a Result of a list.\n * Short-circuits on the first Err.\n * Analogous to Rust `collect::<Result<Vec<_>, _>>()`.\n /\nexport function sequence<const Results extends readonly ResultLike<any, any>[]>(\n results: Results\n): Result<Array<OkValueOf<Results[number]>>, ErrValueOf<Results[number]>> {\n const values: Array<OkValueOf<Results[number]>> = [];\n\n for (const result of results) {\n if (result.isOk()) {\n values.push(result.value as OkValueOf<Results[number]>);\n continue;\n }\n if (result.isErr()) {\n return result as unknown as Result<Array<OkValueOf<Results[number]>>, ErrValueOf<Results[number]>>;\n }\n throw new Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return ok<Array<OkValueOf<Results[number]>>, ErrValueOf<Results[number]>>(values);\n}\n\n/\n Alias for `sequence`.\n /\nexport function all<const Results extends readonly ResultLike<any, any>[]>(\n results: Results\n): Result<Array<OkValueOf<Results[number]>>, ErrValueOf<Results[number]>> {\n return sequence(results);\n}\n","import type { Result } from '../result';\nimport { ok } from '../result';\n\ntype ResultLike<T, E> = {\n isOk(): boolean;\n isErr(): boolean;\n readonly value: T \| undefined;\n readonly error: E \| undefined;\n};\n\ntype OkValueOf<R> = R extends ResultLike<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends ResultLike<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, ResultLike<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) {\n throw new Error(`Missing Result for key \"${String(key)}\"`);\n }\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 Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return ok<Out, E>(out as Out);\n}\n","import type { Result } from '../result';\nimport { ok, err } from '../result';\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<T, E>(\n results: readonly (Result<T, E> \| Result<T, never> \| Result<never, E>)[]\n): Result<T, E[]> {\n const errors: E[] = [];\n\n for (const result of results) {\n if (result.isOk()) {\n return ok<T, E[]>(result.value);\n }\n if (result.isErr()) {\n errors.push(result.error);\n continue;\n }\n throw new Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return err<E[], T>(errors);\n}\n","import type { Result } from '../result';\nimport { ok, err } from '../result';\nimport type { Awaitable } from '../pipeable';\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 - Accepts 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 when 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 Error('Unreachable: Result is neither Ok nor Err');\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';\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/race variant 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 * - Note: There is no cancellation logic. All inputs keep running even after the first `Ok` is found.\n /\nexport async function collectFirstOkRaceAsync<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 UNSET = Symbol('unset');\n const errorsByIndex: Array<ErrValue \| typeof UNSET> = Array(inputs.length).fill(UNSET);\n\n return new Promise<Result<OkValue, ErrValue[]>>((resolve) => {\n let done = false;\n let remaining = inputs.length;\n\n const finishAllErr = () => {\n const errors: ErrValue[] = [];\n for (const entry of errorsByIndex) {\n if (entry !== UNSET) errors.push(entry);\n }\n resolve(err<ErrValue[], OkValue>(errors));\n };\n\n const settleError = (index: number, errorValue: ErrValue) => {\n if (done) return;\n errorsByIndex[index] = errorValue;\n remaining -= 1;\n if (remaining === 0) {\n done = true;\n finishAllErr();\n }\n };\n\n inputs.forEach((input, index) => {\n Promise.resolve()\n .then(() => (typeof input === 'function' ? input() : input))\n .then((result) => {\n if (done) return;\n if (result.isOk()) {\n done = true;\n resolve(ok<OkValue, ErrValue[]>(result.value as OkValue));\n return;\n }\n if (result.isErr()) {\n settleError(index, result.error as ErrValue);\n return;\n }\n settleError(index, new Error('Unreachable: Result is neither Ok nor Err') as ErrValue);\n })\n .catch((caught) => {\n settleError(index, caught as ErrValue);\n });\n });\n });\n}\n","import type { Result } from '../result';\nimport { ok, err } from '../result';\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 Combines a list of Results.\n * Returns Ok(values) only if all are Ok, otherwise Err([errors]).\n /\nexport function collectAllErrors<const Results extends readonly Result<any, any>[]>(\n results: Results\n): Result<Array<OkValueOf<Results[number]>>, Array<ErrValueOf<Results[number]>>> {\n const values: Array<OkValueOf<Results[number]>> = [];\n const errors: Array<ErrValueOf<Results[number]>> = [];\n\n for (const result of results) {\n if (result.isOk()) {\n values.push(result.value as OkValueOf<Results[number]>);\n continue;\n }\n if (result.isErr()) {\n errors.push(result.error as ErrValueOf<Results[number]>);\n continue;\n }\n throw new Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return errors.length === 0\n ? ok(values)\n : err<Array<ErrValueOf<Results[number]>>, Array<OkValueOf<Results[number]>>>(errors);\n}\n","import type { Result } from '../result';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\n\n/\n Checks whether a Result is Ok.\n * Pure function alternative to the instance method.\n /\nexport function isOk<T, E>(result: Result<T, E>): result is Result<T, E> & { readonly value: T; readonly error: undefined } {\n return result.isOk();\n}\n","import type { Result } from '../result';\n\n/\n Checks whether a Result is Err.\n * Pure function alternative to the instance method.\n /\nexport function isErr<T, E>(result: Result<T, E>): result is Result<T, E> & { readonly value: undefined; readonly error: E } {\n return result.isErr();\n}\n","import type { Result } from '../result';\n\n/\n Checks whether the Result contains a specific value.\n * Equivalent to Rust `contains`.\n /\nexport function contains<T, E>(result: Result<any, 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 whether 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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"}
1	+ {"version":3,"file":"index.mjs","names":["ret: any","#error","#matched","#value","isResult","#makeErr","#resolved","mapErr","right","left","errors: Array<AE \| BE>","errors: Array<ErrValueOf<Results[number]>>","input: unknown","step: IteratorResult<Y, R>","values: T[]","out: Partial<Out>","errors: Array<ErrValueOfInput<Inputs[number]>>","errors: ErrValue[]","values: T[]","errors: E[]","oks: Array<OkValueOf<Results[number]>>","errs: Array<ErrValueOf<Results[number]>>"],"sources":["../src/core/pipeable.ts","../src/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","import type { Result } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\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\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n\n/\n Alias für `mapBoth`.\n /\nexport const bimap = mapBoth;\n\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 { 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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\n}\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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 Error('match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.');\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';\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 TypeError('task() expected yielded values to be Result. Use `yield` on a Result.');\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 Error('Unreachable: Result is neither Ok nor Err');\n }\n}\n\nexport const gen = task;\n","import type { Result } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n","import type { Result } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\n };\n}\n","import type { Result } from './result';\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 Error(`Called unwrap() on Err: ${String(result.error)}`);\n throw new Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n}\n\n","import type { Result } from './result';\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 Error(`Called unwrapErr() on Ok: ${String(result.value)}`);\n throw new Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from './result';\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 Error(message);\n}\n","import type { Result } from './result';\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 Error(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';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n}\n","import type { Result } from './result';\nimport { ok } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return ok<Out, E>(out as Out);\n}\n\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport type { Awaitable } from './pipeable';\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 Error('Unreachable: Result is neither Ok nor Err');\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';\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 Error('Unreachable: Result is neither Ok nor Err') 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';\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 Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return errors.length === 0 ? ok(values) : err<E[], T[]>(errors);\n}\n","import type { Result } from './result';\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 Error('Unreachable: Result is neither Ok nor Err');\n }\n\n return [oks, errs];\n}\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';\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 Error('Unreachable: Result is neither Ok nor Err');\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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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@shirudo/result",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Robust, type-safe error handling for TypeScript using the Result pattern (Monad)",
   "type": "module",
   "private": false,
@@ -38,6 +38,15 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "typecheck": "tsc --noEmit --emitDeclarationOnly false",
+    "lint": "tsc --noEmit --emitDeclarationOnly false",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prebuild": "pnpm lint && pnpm test run",
+    "build": "tsdown",
+    "prepublishOnly": "pnpm build"
+  },
   "devDependencies": {
     "@types/node": "^25.0.2",
     "@vitest/coverage-v8": "^4.0.15",
@@ -45,13 +54,5 @@
     "tsx": "^4.21.0",
     "typescript": "^5.7.3",
     "vitest": "^4.0.15"
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit --emitDeclarationOnly false",
-    "lint": "tsc --noEmit --emitDeclarationOnly false",
-    "test": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "prebuild": "pnpm lint && pnpm test run",
-    "build": "tsdown"
   }
-}
+}