@nlozgachev/pipelined 0.42.0 → 0.43.0

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 (31) hide show
  1. package/dist/InternalTypes-DsCqxWZm.d.mts +118 -0
  2. package/dist/InternalTypes-DuzMFAfJ.d.ts +118 -0
  3. package/dist/{Task-BprUabHP.d.mts → Validation-BOPLiDqa.d.ts} +875 -111
  4. package/dist/{Task-Dt3ZMen6.d.ts → Validation-Do6uWLLZ.d.mts} +875 -111
  5. package/dist/{chunk-GBB6LVLI.mjs → chunk-74JKKJ4R.mjs} +0 -4
  6. package/dist/{chunk-OAP765G3.mjs → chunk-CHRXZIJU.mjs} +177 -135
  7. package/dist/{chunk-6VYLZTAM.mjs → chunk-W6RWKBDX.mjs} +157 -69
  8. package/dist/{chunk-F6SBU7GB.mjs → chunk-X6XQX3OZ.mjs} +3 -3
  9. package/dist/composition.d.mts +45 -44
  10. package/dist/composition.d.ts +45 -44
  11. package/dist/composition.js +2 -2
  12. package/dist/composition.mjs +2 -2
  13. package/dist/core.d.mts +10 -812
  14. package/dist/core.d.ts +10 -812
  15. package/dist/core.js +175 -137
  16. package/dist/core.mjs +2 -8
  17. package/dist/index.d.mts +5 -5
  18. package/dist/index.d.ts +5 -5
  19. package/dist/index.js +331 -208
  20. package/dist/index.mjs +5 -13
  21. package/dist/types.d.mts +112 -17
  22. package/dist/types.d.ts +112 -17
  23. package/dist/types.js +2 -7
  24. package/dist/types.mjs +3 -5
  25. package/dist/utils.d.mts +345 -89
  26. package/dist/utils.d.ts +345 -89
  27. package/dist/utils.js +429 -107
  28. package/dist/utils.mjs +3 -3
  29. package/package.json +2 -2
  30. package/dist/Duration-BTeT9D-q.d.mts +0 -127
  31. package/dist/Duration-BTeT9D-q.d.ts +0 -127
package/dist/{chunk-F6SBU7GB.mjs → chunk-X6XQX3OZ.mjs} RENAMED
@@ -1,6 +1,6 @@
1
1
  import {
2
2
  Duration
3
- } from "./chunk-GBB6LVLI.mjs";
3
+ } from "./chunk-74JKKJ4R.mjs";
4
4
 
5
5
  // src/Composition/compose.ts
6
6
  function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
@@ -368,7 +368,7 @@ function tap(f) {
368
368
  };
369
369
  tap2.async = (fn, options) => (a) => {
370
370
  const onError = options?.onError ?? console.error;
371
- fn(a).catch((err) => {
371
+ Promise.resolve(fn(a)).catch((err) => {
372
372
  onError(err);
373
373
  });
374
374
  return a;
@@ -384,7 +384,7 @@ function tap(f) {
384
384
  };
385
385
  try {
386
386
  const res = fn(a);
387
- if (res instanceof Promise) {
387
+ if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
388
388
  res.then(() => {
389
389
  const duration = Duration.milliseconds(performance.now() - start);
390
390
  triggerFinish(duration);
package/dist/composition.d.mts CHANGED
@@ -1,4 +1,5 @@
1
- import { D as Duration } from './Duration-BTeT9D-q.mjs';
1
+ import { A as Awaitable, T as Thenable } from './InternalTypes-DsCqxWZm.mjs';
2
+ import { Duration } from './types.mjs';
2
3
 
3
4
  /**
4
5
  * Composes functions from right to left, returning a new function.
@@ -132,16 +133,16 @@ declare function safe$1<A, B, C, D, E, F, G, H>(ab: (a: NonNullable<A>) => B, bc
132
133
  declare function safe$1<A, B, C, D, E, F, G, H, I>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): (a: A) => I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
133
134
  declare function safe$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): (a: A) => J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
134
135
  declare function safe$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
135
- declare function async$1<A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
136
- declare function async$1<A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
137
- declare function async$1<A, B, C, D>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): (a: A | Promise<A>) => Promise<D>;
138
- declare function async$1<A, B, C, D, E>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): (a: A | Promise<A>) => Promise<E>;
139
- declare function async$1<A, B, C, D, E, F>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): (a: A | Promise<A>) => Promise<F>;
140
- declare function async$1<A, B, C, D, E, F, G>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): (a: A | Promise<A>) => Promise<G>;
141
- declare function async$1<A, B, C, D, E, F, G, H>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): (a: A | Promise<A>) => Promise<H>;
142
- declare function async$1<A, B, C, D, E, F, G, H, I>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): (a: A | Promise<A>) => Promise<I>;
143
- declare function async$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): (a: A | Promise<A>) => Promise<J>;
144
- declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): (a: A | Promise<A>) => Promise<K>;
136
+ declare function async$1<A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
137
+ declare function async$1<A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
138
+ declare function async$1<A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
139
+ declare function async$1<A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
140
+ declare function async$1<A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
141
+ declare function async$1<A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
142
+ declare function async$1<A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
143
+ declare function async$1<A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
144
+ declare function async$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
145
+ declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
145
146
  /**
146
147
  * Composes functions from left to right, returning a new function.
147
148
  * Unlike `pipe`, `flow` doesn't take an initial value - it creates
@@ -210,16 +211,16 @@ declare namespace flow {
210
211
  <A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
211
212
  };
212
213
  export var async: {
213
- <A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
214
- <A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
215
- <A, B, C, D>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): (a: A | Promise<A>) => Promise<D>;
216
- <A, B, C, D, E>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): (a: A | Promise<A>) => Promise<E>;
217
- <A, B, C, D, E, F>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): (a: A | Promise<A>) => Promise<F>;
218
- <A, B, C, D, E, F, G>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): (a: A | Promise<A>) => Promise<G>;
219
- <A, B, C, D, E, F, G, H>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): (a: A | Promise<A>) => Promise<H>;
220
- <A, B, C, D, E, F, G, H, I>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): (a: A | Promise<A>) => Promise<I>;
221
- <A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): (a: A | Promise<A>) => Promise<J>;
222
- <A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): (a: A | Promise<A>) => Promise<K>;
214
+ <A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
215
+ <A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
216
+ <A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
217
+ <A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
218
+ <A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
219
+ <A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
220
+ <A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
221
+ <A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
222
+ <A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
223
+ <A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
223
224
  };
224
225
  var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
225
226
  export { _a as try };
@@ -462,17 +463,17 @@ declare function safe<A, B, C, D, E, F, G, H>(a: A, ab: (a: NonNullable<A>) => B
462
463
  declare function safe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
463
464
  declare function safe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
464
465
  declare function safe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
465
- declare function async<A>(a: A | Promise<A>): Promise<A>;
466
- declare function async<A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
467
- declare function async<A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
468
- declare function async<A, B, C, D>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): Promise<D>;
469
- declare function async<A, B, C, D, E>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): Promise<E>;
470
- declare function async<A, B, C, D, E, F>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): Promise<F>;
471
- declare function async<A, B, C, D, E, F, G>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): Promise<G>;
472
- declare function async<A, B, C, D, E, F, G, H>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): Promise<H>;
473
- declare function async<A, B, C, D, E, F, G, H, I>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): Promise<I>;
474
- declare function async<A, B, C, D, E, F, G, H, I, J>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): Promise<J>;
475
- declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): Promise<K>;
466
+ declare function async<A>(a: Awaitable<A>): Promise<A>;
467
+ declare function async<A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
468
+ declare function async<A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
469
+ declare function async<A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
470
+ declare function async<A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
471
+ declare function async<A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
472
+ declare function async<A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
473
+ declare function async<A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
474
+ declare function async<A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
475
+ declare function async<A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
476
+ declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
476
477
  /**
477
478
  * Pipes a value through a series of functions from left to right.
478
479
  * Each function receives the output of the previous function.
@@ -541,17 +542,17 @@ declare namespace pipe {
541
542
  <A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
542
543
  };
543
544
  export var async: {
544
- <A>(a: A | Promise<A>): Promise<A>;
545
- <A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
546
- <A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
547
- <A, B, C, D>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): Promise<D>;
548
- <A, B, C, D, E>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): Promise<E>;
549
- <A, B, C, D, E, F>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): Promise<F>;
550
- <A, B, C, D, E, F, G>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): Promise<G>;
551
- <A, B, C, D, E, F, G, H>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): Promise<H>;
552
- <A, B, C, D, E, F, G, H, I>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): Promise<I>;
553
- <A, B, C, D, E, F, G, H, I, J>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): Promise<J>;
554
- <A, B, C, D, E, F, G, H, I, J, K>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): Promise<K>;
545
+ <A>(a: Awaitable<A>): Promise<A>;
546
+ <A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
547
+ <A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
548
+ <A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
549
+ <A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
550
+ <A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
551
+ <A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
552
+ <A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
553
+ <A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
554
+ <A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
555
+ <A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
555
556
  };
556
557
  var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
557
558
  export { _a as try };
@@ -720,7 +721,7 @@ declare namespace tap {
720
721
  * );
721
722
  * ```
722
723
  */
723
- const async: <A>(fn: (a: A) => Promise<unknown>, options?: AsyncOptions) => (a: A) => A;
724
+ const async: <A>(fn: (a: A) => Thenable<unknown>, options?: AsyncOptions) => (a: A) => A;
724
725
  /**
725
726
  * Runs a function and measures its execution duration, returning the value unchanged.
726
727
  * Supports both synchronous and asynchronous functions. If the timed function returns
package/dist/composition.d.ts CHANGED
@@ -1,4 +1,5 @@
1
- import { D as Duration } from './Duration-BTeT9D-q.js';
1
+ import { A as Awaitable, T as Thenable } from './InternalTypes-DuzMFAfJ.js';
2
+ import { Duration } from './types.js';
2
3
 
3
4
  /**
4
5
  * Composes functions from right to left, returning a new function.
@@ -132,16 +133,16 @@ declare function safe$1<A, B, C, D, E, F, G, H>(ab: (a: NonNullable<A>) => B, bc
132
133
  declare function safe$1<A, B, C, D, E, F, G, H, I>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): (a: A) => I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
133
134
  declare function safe$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): (a: A) => J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
134
135
  declare function safe$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
135
- declare function async$1<A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
136
- declare function async$1<A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
137
- declare function async$1<A, B, C, D>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): (a: A | Promise<A>) => Promise<D>;
138
- declare function async$1<A, B, C, D, E>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): (a: A | Promise<A>) => Promise<E>;
139
- declare function async$1<A, B, C, D, E, F>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): (a: A | Promise<A>) => Promise<F>;
140
- declare function async$1<A, B, C, D, E, F, G>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): (a: A | Promise<A>) => Promise<G>;
141
- declare function async$1<A, B, C, D, E, F, G, H>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): (a: A | Promise<A>) => Promise<H>;
142
- declare function async$1<A, B, C, D, E, F, G, H, I>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): (a: A | Promise<A>) => Promise<I>;
143
- declare function async$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): (a: A | Promise<A>) => Promise<J>;
144
- declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): (a: A | Promise<A>) => Promise<K>;
136
+ declare function async$1<A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
137
+ declare function async$1<A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
138
+ declare function async$1<A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
139
+ declare function async$1<A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
140
+ declare function async$1<A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
141
+ declare function async$1<A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
142
+ declare function async$1<A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
143
+ declare function async$1<A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
144
+ declare function async$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
145
+ declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
145
146
  /**
146
147
  * Composes functions from left to right, returning a new function.
147
148
  * Unlike `pipe`, `flow` doesn't take an initial value - it creates
@@ -210,16 +211,16 @@ declare namespace flow {
210
211
  <A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
211
212
  };
212
213
  export var async: {
213
- <A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
214
- <A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
215
- <A, B, C, D>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): (a: A | Promise<A>) => Promise<D>;
216
- <A, B, C, D, E>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): (a: A | Promise<A>) => Promise<E>;
217
- <A, B, C, D, E, F>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): (a: A | Promise<A>) => Promise<F>;
218
- <A, B, C, D, E, F, G>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): (a: A | Promise<A>) => Promise<G>;
219
- <A, B, C, D, E, F, G, H>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): (a: A | Promise<A>) => Promise<H>;
220
- <A, B, C, D, E, F, G, H, I>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): (a: A | Promise<A>) => Promise<I>;
221
- <A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): (a: A | Promise<A>) => Promise<J>;
222
- <A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): (a: A | Promise<A>) => Promise<K>;
214
+ <A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
215
+ <A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
216
+ <A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
217
+ <A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
218
+ <A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
219
+ <A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
220
+ <A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
221
+ <A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
222
+ <A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
223
+ <A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
223
224
  };
224
225
  var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
225
226
  export { _a as try };
@@ -462,17 +463,17 @@ declare function safe<A, B, C, D, E, F, G, H>(a: A, ab: (a: NonNullable<A>) => B
462
463
  declare function safe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
463
464
  declare function safe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
464
465
  declare function safe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
465
- declare function async<A>(a: A | Promise<A>): Promise<A>;
466
- declare function async<A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
467
- declare function async<A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
468
- declare function async<A, B, C, D>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): Promise<D>;
469
- declare function async<A, B, C, D, E>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): Promise<E>;
470
- declare function async<A, B, C, D, E, F>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): Promise<F>;
471
- declare function async<A, B, C, D, E, F, G>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): Promise<G>;
472
- declare function async<A, B, C, D, E, F, G, H>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): Promise<H>;
473
- declare function async<A, B, C, D, E, F, G, H, I>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): Promise<I>;
474
- declare function async<A, B, C, D, E, F, G, H, I, J>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): Promise<J>;
475
- declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): Promise<K>;
466
+ declare function async<A>(a: Awaitable<A>): Promise<A>;
467
+ declare function async<A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
468
+ declare function async<A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
469
+ declare function async<A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
470
+ declare function async<A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
471
+ declare function async<A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
472
+ declare function async<A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
473
+ declare function async<A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
474
+ declare function async<A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
475
+ declare function async<A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
476
+ declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
476
477
  /**
477
478
  * Pipes a value through a series of functions from left to right.
478
479
  * Each function receives the output of the previous function.
@@ -541,17 +542,17 @@ declare namespace pipe {
541
542
  <A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
542
543
  };
543
544
  export var async: {
544
- <A>(a: A | Promise<A>): Promise<A>;
545
- <A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
546
- <A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
547
- <A, B, C, D>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>): Promise<D>;
548
- <A, B, C, D, E>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>): Promise<E>;
549
- <A, B, C, D, E, F>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>): Promise<F>;
550
- <A, B, C, D, E, F, G>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>): Promise<G>;
551
- <A, B, C, D, E, F, G, H>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>): Promise<H>;
552
- <A, B, C, D, E, F, G, H, I>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>): Promise<I>;
553
- <A, B, C, D, E, F, G, H, I, J>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J): Promise<J>;
554
- <A, B, C, D, E, F, G, H, I, J, K>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>, cd: (c: C) => D | Promise<D>, de: (d: D) => E | Promise<E>, ef: (e: E) => F | Promise<F>, fg: (f: F) => G | Promise<G>, gh: (g: G) => H | Promise<H>, hi: (h: H) => I | Promise<I>, ij: (i: I) => J | Promise<J>, jk: (j: J) => K | Promise<K>): Promise<K>;
545
+ <A>(a: Awaitable<A>): Promise<A>;
546
+ <A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
547
+ <A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
548
+ <A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
549
+ <A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
550
+ <A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
551
+ <A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
552
+ <A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
553
+ <A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
554
+ <A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
555
+ <A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
555
556
  };
556
557
  var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
557
558
  export { _a as try };
@@ -720,7 +721,7 @@ declare namespace tap {
720
721
  * );
721
722
  * ```
722
723
  */
723
- const async: <A>(fn: (a: A) => Promise<unknown>, options?: AsyncOptions) => (a: A) => A;
724
+ const async: <A>(fn: (a: A) => Thenable<unknown>, options?: AsyncOptions) => (a: A) => A;
724
725
  /**
725
726
  * Runs a function and measures its execution duration, returning the value unchanged.
726
727
  * Supports both synchronous and asynchronous functions. If the timed function returns
package/dist/composition.js CHANGED
@@ -444,7 +444,7 @@ function tap(f) {
444
444
  };
445
445
  tap2.async = (fn, options) => (a) => {
446
446
  const onError = options?.onError ?? console.error;
447
- fn(a).catch((err) => {
447
+ Promise.resolve(fn(a)).catch((err) => {
448
448
  onError(err);
449
449
  });
450
450
  return a;
@@ -460,7 +460,7 @@ function tap(f) {
460
460
  };
461
461
  try {
462
462
  const res = fn(a);
463
- if (res instanceof Promise) {
463
+ if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
464
464
  res.then(() => {
465
465
  const duration = Duration.milliseconds(performance.now() - start);
466
466
  triggerFinish(duration);
package/dist/composition.mjs CHANGED
@@ -27,8 +27,8 @@ import {
27
27
  uncurry,
28
28
  uncurry3,
29
29
  uncurry4
30
- } from "./chunk-F6SBU7GB.mjs";
31
- import "./chunk-GBB6LVLI.mjs";
30
+ } from "./chunk-X6XQX3OZ.mjs";
31
+ import "./chunk-74JKKJ4R.mjs";
32
32
  export {
33
33
  and,
34
34
  compose,