@nlozgachev/pipelined 0.41.0 → 0.43.0

package/dist/{chunk-V37OUM35.mjs → chunk-W6RWKBDX.mjs}

@@ -2,13 +2,73 @@ import {
   Deferred,
   Maybe,
   Result,
-  Task
-} from "./chunk-COGQKPIP.mjs";
-import {
-  isNonEmptyList
-} from "./chunk-GBB6LVLI.mjs";
+  Task,
+  isNonEmptyArr
+} from "./chunk-CHRXZIJU.mjs";
 
 // src/Data/Arr.ts
+var ArrMaybe;
+((ArrMaybe2) => {
+  ArrMaybe2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "None") {
+        return Maybe.none();
+      }
+      result[i] = mapped.value;
+    }
+    return Maybe.some(result);
+  };
+  ArrMaybe2.sequence = (data) => (0, ArrMaybe2.traverse)((a) => a)(data);
+})(ArrMaybe || (ArrMaybe = {}));
+var ArrResult;
+((ArrResult2) => {
+  ArrResult2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Err") {
+        return mapped;
+      }
+      result[i] = mapped.value;
+    }
+    return Result.ok(result);
+  };
+  ArrResult2.sequence = (data) => (0, ArrResult2.traverse)((a) => a)(data);
+})(ArrResult || (ArrResult = {}));
+var ArrTaskResult;
+((ArrTaskResult2) => {
+  ArrTaskResult2.traverse = (f) => (data) => Task.from(async () => {
+    const result = [];
+    for (const a of data) {
+      const r = await Deferred.toPromise(f(a)());
+      if (Result.isErr(r)) {
+        return r;
+      }
+      result.push(r.value);
+    }
+    return Result.ok(result);
+  });
+  ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
+})(ArrTaskResult || (ArrTaskResult = {}));
+var ArrTask;
+((ArrTask2) => {
+  ArrTask2.traverse = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
+  ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
+  ArrTask2.Result = ArrTaskResult;
+})(ArrTask || (ArrTask = {}));
+var ArrNonEmpty;
+((ArrNonEmpty2) => {
+  ArrNonEmpty2.singleton = (value) => [value];
+  ArrNonEmpty2.fromArray = (data) => isNonEmptyArr(data) ? Maybe.some(data) : Maybe.none();
+  ArrNonEmpty2.head = (data) => data[0];
+  ArrNonEmpty2.last = (data) => data[data.length - 1];
+  ArrNonEmpty2.tail = (data) => data.slice(1);
+  ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
+})(ArrNonEmpty || (ArrNonEmpty = {}));
 var Arr;
 ((Arr2) => {
   Arr2.head = (data) => data.length > 0 ? Maybe.some(data[0]) : Maybe.none();
@@ -182,6 +242,7 @@ var Arr;
     }
     return result;
   };
+  Arr2.concat = (other) => (data) => [...data, ...other];
   Arr2.chunksOf = (n) => (data) => {
     if (n <= 0) {
       return [];
@@ -222,47 +283,12 @@ var Arr;
     return result;
   };
   Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
-  Arr2.traverse = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "None") {
-        return Maybe.none();
-      }
-      result[i] = mapped.value;
-    }
-    return Maybe.some(result);
-  };
-  Arr2.traverseResult = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "Err") {
-        return mapped;
-      }
-      result[i] = mapped.value;
-    }
-    return Result.ok(result);
-  };
-  Arr2.traverseTask = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
-  Arr2.sequence = (data) => (0, Arr2.traverse)((a) => a)(data);
-  Arr2.sequenceResult = (data) => (0, Arr2.traverseResult)((a) => a)(data);
-  Arr2.sequenceTask = (data) => (0, Arr2.traverseTask)((a) => a)(data);
-  Arr2.traverseTaskResult = (f) => (data) => Task.from(async () => {
-    const result = [];
-    for (const a of data) {
-      const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) {
-        return r;
-      }
-      result.push(r.value);
-    }
-    return Result.ok(result);
-  });
-  Arr2.sequenceTaskResult = (data) => (0, Arr2.traverseTaskResult)((a) => a)(data);
-  Arr2.isNonEmpty = (data) => isNonEmptyList(data);
+  Arr2.Maybe = ArrMaybe;
+  Arr2.Result = ArrResult;
+  Arr2.Task = ArrTask;
+  Arr2.isNonEmpty = (data) => isNonEmptyArr(data);
+  Arr2.prepend = (value) => (data) => [value, ...data];
+  Arr2.append = (value) => (data) => [...data, value];
   Arr2.size = (data) => data.length;
   Arr2.some = (predicate) => (data) => {
     const n = data.length;
@@ -338,6 +364,7 @@ var Arr;
     const i = Math.max(0, index);
     return [data.slice(0, i), data.slice(i)];
   };
+  Arr2.NonEmpty = ArrNonEmpty;
 })(Arr || (Arr = {}));
 
 // src/Data/Dict.ts
@@ -547,25 +574,78 @@ var Num;
 })(Num || (Num = {}));
 
 // src/Data/Rec.ts
+var _isNonEmpty = (data) => Object.keys(data).length > 0;
+var RecMaybe;
+((RecMaybe2) => {
+  RecMaybe2.traverse = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const result = {};
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      const maybeVal = f(data[key]);
+      if (maybeVal.kind === "None") {
+        return maybeVal;
+      }
+      Object.defineProperty(result, key, { value: maybeVal.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "Some", value: result };
+  };
+  RecMaybe2.sequence = (data) => (0, RecMaybe2.traverse)((a) => a)(data);
+})(RecMaybe || (RecMaybe = {}));
+var RecResult;
+((RecResult2) => {
+  RecResult2.traverse = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const result = {};
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      const res = f(data[key]);
+      if (res.kind === "Err") {
+        return res;
+      }
+      Object.defineProperty(result, key, { value: res.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "Ok", value: result };
+  };
+  RecResult2.sequence = (data) => (0, RecResult2.traverse)((a) => a)(data);
+})(RecResult || (RecResult = {}));
+var RecNonEmpty;
+((RecNonEmpty2) => {
+  RecNonEmpty2.singleton = (key, value) => ({ [key]: value });
+  RecNonEmpty2.fromRecord = (data) => _isNonEmpty(data) ? Maybe.some(data) : Maybe.none();
+  RecNonEmpty2.keys = (data) => Object.keys(data);
+  RecNonEmpty2.values = (data) => Object.values(data);
+  RecNonEmpty2.entries = (data) => Object.entries(data);
+  RecNonEmpty2.reduce = (f) => (data) => {
+    const recordVals = Object.values(data);
+    return recordVals.reduce(f);
+  };
+})(RecNonEmpty || (RecNonEmpty = {}));
 var Rec;
 ((Rec2) => {
-  Rec2.map = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+  Rec2.isNonEmpty = _isNonEmpty;
+  Rec2.map = (f) => ((data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      Object.defineProperty(result, keys2[i], { value: f(vals[i]), writable: true, enumerable: true, configurable: true });
+    for (let i = 0; i < recordKeys.length; i++) {
+      Object.defineProperty(result, recordKeys[i], {
+        value: f(recordValues[i]),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     }
     return result;
-  };
+  });
   Rec2.filterMap = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      const maybeVal = f(vals[i]);
+    for (let i = 0; i < recordKeys.length; i++) {
+      const maybeVal = f(recordValues[i]);
       if (maybeVal.kind === "Some") {
-        Object.defineProperty(result, keys2[i], {
+        Object.defineProperty(result, recordKeys[i], {
           value: maybeVal.value,
           writable: true,
           enumerable: true,
@@ -575,27 +655,32 @@ var Rec;
     }
     return result;
   };
-  Rec2.mapWithKey = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+  Rec2.mapWithKey = (f) => ((data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      Object.defineProperty(result, keys2[i], {
-        value: f(keys2[i], vals[i]),
+    for (let i = 0; i < recordKeys.length; i++) {
+      Object.defineProperty(result, recordKeys[i], {
+        value: f(recordKeys[i], recordValues[i]),
         writable: true,
         enumerable: true,
         configurable: true
       });
     }
     return result;
-  };
+  });
   Rec2.filter = (predicate) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      if (predicate(vals[i])) {
-        Object.defineProperty(result, keys2[i], { value: vals[i], writable: true, enumerable: true, configurable: true });
+    for (let i = 0; i < recordKeys.length; i++) {
+      if (predicate(recordValues[i])) {
+        Object.defineProperty(result, recordKeys[i], {
+          value: recordValues[i],
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
       }
     }
     return result;
@@ -672,6 +757,9 @@ var Rec;
     }
     return result;
   };
+  Rec2.Maybe = RecMaybe;
+  Rec2.Result = RecResult;
+  Rec2.NonEmpty = RecNonEmpty;
 })(Rec || (Rec = {}));
 
 // src/Data/Str.ts

package/dist/{chunk-TCE2UETM.mjs → chunk-X6XQX3OZ.mjs}

@@ -1,6 +1,6 @@
 import {
   Duration
-} from "./chunk-GBB6LVLI.mjs";
+} from "./chunk-74JKKJ4R.mjs";
 
 // src/Composition/compose.ts
 function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
@@ -368,7 +368,7 @@ function tap(f) {
   };
   tap2.async = (fn, options) => (a) => {
     const onError = options?.onError ?? console.error;
-    fn(a).catch((err) => {
+    Promise.resolve(fn(a)).catch((err) => {
       onError(err);
     });
     return a;
@@ -378,13 +378,13 @@ function tap(f) {
     const triggerFinish = (duration) => {
       if (config.label !== void 0) {
         console.log(`[${config.label}]: ${Duration.toMilliseconds(duration)}ms`);
-      } else if (config.onFinish) {
+      } else {
         config.onFinish(duration);
       }
     };
     try {
       const res = fn(a);
-      if (res instanceof Promise) {
+      if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
         res.then(() => {
           const duration = Duration.milliseconds(performance.now() - start);
           triggerFinish(duration);

package/dist/composition.d.mts

@@ -1,4 +1,5 @@
-import { D as Duration } from './Duration-BTeT9D-q.mjs';
+import { A as Awaitable, T as Thenable } from './InternalTypes-DsCqxWZm.mjs';
+import { Duration } from './types.mjs';
 
 /**
  * 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
 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>;
 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>;
 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>;
-declare function async$1<A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
+declare function async$1<A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
+declare function async$1<A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
+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>;
+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>;
+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>;
+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>;
+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>;
+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>;
+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>;
+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>;
 /**
  * Composes functions from left to right, returning a new function.
  * Unlike `pipe`, `flow` doesn't take an initial value - it creates
@@ -210,16 +211,16 @@ declare namespace flow {
         <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>;
     };
     export var async: {
-        <A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
-        <A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
+        <A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
+        <A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
+        <A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
     };
     var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
     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
 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>;
 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>;
 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>;
-declare function async<A>(a: A | Promise<A>): Promise<A>;
-declare function async<A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
-declare function async<A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
-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>;
+declare function async<A>(a: Awaitable<A>): Promise<A>;
+declare function async<A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
+declare function async<A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
+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>;
+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>;
+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>;
+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>;
+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>;
+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>;
+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>;
+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>;
 /**
  * Pipes a value through a series of functions from left to right.
  * Each function receives the output of the previous function.
@@ -541,17 +542,17 @@ declare namespace pipe {
         <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>;
     };
     export var async: {
-        <A>(a: A | Promise<A>): Promise<A>;
-        <A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
-        <A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
-        <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>;
+        <A>(a: Awaitable<A>): Promise<A>;
+        <A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
+        <A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
+        <A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
+        <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>;
     };
     var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
     export { _a as try };
@@ -720,7 +721,7 @@ declare namespace tap {
      * );
      * ```
      */
-    const async: <A>(fn: (a: A) => Promise<unknown>, options?: AsyncOptions) => (a: A) => A;
+    const async: <A>(fn: (a: A) => Thenable<unknown>, options?: AsyncOptions) => (a: A) => A;
     /**
      * Runs a function and measures its execution duration, returning the value unchanged.
      * Supports both synchronous and asynchronous functions. If the timed function returns