@nlozgachev/pipelined 0.35.0 → 0.37.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 (24) hide show
  1. package/README.md +69 -92
  2. package/dist/{Task-zAY4kSVB.d.ts → Task-DIgwvoIb.d.ts} +67 -1
  3. package/dist/{Task-DXsuurnc.d.mts → Task-fn1n--6H.d.mts} +67 -1
  4. package/dist/{chunk-AHEZFTMT.mjs → chunk-3Q5UBRYB.mjs} +92 -0
  5. package/dist/{chunk-IJFFWBKW.mjs → chunk-72BGUEQM.mjs} +1 -1
  6. package/dist/{chunk-DLBHVYII.mjs → chunk-PUMSVZB4.mjs} +12 -0
  7. package/dist/{chunk-5AWUAG7G.mjs → chunk-SHO53CQC.mjs} +26 -6
  8. package/dist/composition.d.mts +189 -1
  9. package/dist/composition.d.ts +189 -1
  10. package/dist/composition.js +93 -0
  11. package/dist/composition.mjs +3 -1
  12. package/dist/core.d.mts +113 -7
  13. package/dist/core.d.ts +113 -7
  14. package/dist/core.js +37 -5
  15. package/dist/core.mjs +2 -2
  16. package/dist/index.d.mts +2 -2
  17. package/dist/index.d.ts +2 -2
  18. package/dist/index.js +130 -5
  19. package/dist/index.mjs +6 -4
  20. package/dist/utils.d.mts +1 -1
  21. package/dist/utils.d.ts +1 -1
  22. package/dist/utils.js +12 -0
  23. package/dist/utils.mjs +2 -2
  24. package/package.json +8 -3
package/dist/composition.d.mts CHANGED
@@ -120,6 +120,26 @@ declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A
120
120
  */
121
121
  declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
122
122
 
123
+ declare function safe$1<A, B>(ab: (a: NonNullable<A>) => B): (a: A) => B | Extract<A, null | undefined>;
124
+ declare function safe$1<A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
125
+ declare function safe$1<A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
126
+ declare function safe$1<A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
127
+ declare function safe$1<A, B, C, D, E, F>(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): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
128
+ declare function safe$1<A, B, C, D, E, F, G>(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): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
129
+ declare function safe$1<A, B, C, D, E, F, G, H>(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): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
130
+ 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>;
131
+ 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>;
132
+ 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>;
133
+ declare function async$1<A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
134
+ 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>;
135
+ 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>;
136
+ 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>;
137
+ 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>;
138
+ 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>;
139
+ 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>;
140
+ 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>;
141
+ 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>;
142
+ 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>;
123
143
  /**
124
144
  * Composes functions from left to right, returning a new function.
125
145
  * Unlike `pipe`, `flow` doesn't take an initial value - it creates
@@ -170,6 +190,71 @@ declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H>(ab:
170
190
  declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (...a: A) => I;
171
191
  declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;
172
192
  declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J, K>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): (...a: A) => K;
193
+ declare namespace flow {
194
+ export var when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
195
+ export var unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
196
+ export var either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
197
+ export var struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
198
+ export var safe: {
199
+ <A, B>(ab: (a: NonNullable<A>) => B): (a: A) => B | Extract<A, null | undefined>;
200
+ <A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
201
+ <A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
202
+ <A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
203
+ <A, B, C, D, E, F>(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): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
204
+ <A, B, C, D, E, F, G>(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): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
205
+ <A, B, C, D, E, F, G, H>(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): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
206
+ <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>;
207
+ <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>;
208
+ <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>;
209
+ };
210
+ export var async: {
211
+ <A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
212
+ <A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
213
+ <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>;
214
+ <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>;
215
+ <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>;
216
+ <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>;
217
+ <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>;
218
+ <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>;
219
+ <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>;
220
+ <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>;
221
+ };
222
+ var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
223
+ export { _a as try };
224
+ }
225
+ interface flow {
226
+ /**
227
+ * Executes a function on the piped value if a predicate is met, otherwise returns the value unchanged.
228
+ */
229
+ readonly when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
230
+ /**
231
+ * Executes a function on the piped value if a predicate is NOT met, otherwise returns the value unchanged.
232
+ */
233
+ readonly unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
234
+ /**
235
+ * Executes one of two functions based on a predicate, acting as a functional if-else/ternary helper.
236
+ */
237
+ readonly either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
238
+ /**
239
+ * Creates a pipeline step that wraps a throwing function in a try/catch, returning a fallback value if an error occurs.
240
+ */
241
+ readonly try: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
242
+ /**
243
+ * Builds an object by applying a record of field-level transformer functions to the piped input.
244
+ */
245
+ readonly struct: <A, R extends Record<string, unknown>>(fields: {
246
+ [K in keyof R]: (a: A) => R[K];
247
+ }) => (a: A) => R;
248
+ /**
249
+ * Pipes a value through a sequence of operations, short-circuiting and propagating
250
+ * null or undefined immediately if any intermediate step evaluates to nil.
251
+ */
252
+ readonly safe: typeof safe$1;
253
+ /**
254
+ * Pipes a value through a sequence of operations, supporting asynchronous transitions at any step.
255
+ */
256
+ readonly async: typeof async$1;
257
+ }
173
258
 
174
259
  /**
175
260
  * Returns the value unchanged. The identity function.
@@ -246,6 +331,20 @@ declare const or: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean
246
331
  * ```
247
332
  */
248
333
  declare const once: <A>(f: () => A) => () => A;
334
+ /**
335
+ * Returns a fallback value if the input is null or undefined; otherwise returns the input value.
336
+ * Highly useful as a data-last default value step inside pipelines.
337
+ *
338
+ * @example
339
+ * ```ts
340
+ * const getName = flow(
341
+ * (u: { name?: string | null }) => u.name,
342
+ * defaultTo("Guest"),
343
+ * name => name.toUpperCase()
344
+ * ); // returns string
345
+ * ```
346
+ */
347
+ declare const defaultTo: <B>(fallback: B) => <A>(a: A) => NonNullable<A> | B;
249
348
 
250
349
  /**
251
350
  * Applies an input to an array of functions and collects the results into a tuple.
@@ -350,6 +449,28 @@ declare const not: <A extends ReadonlyArray<unknown>>(predicate: (...args: A) =>
350
449
  */
351
450
  declare const on: <A, B, C>(f: (b1: B, b2: B) => C, g: (a: A) => B) => (a: A, b: A) => C;
352
451
 
452
+ declare function safe<A>(a: A): A;
453
+ declare function safe<A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
454
+ declare function safe<A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
455
+ declare function safe<A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
456
+ declare function safe<A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
457
+ declare function safe<A, B, C, D, E, F>(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): F | Extract<A | B | C | D | E, null | undefined>;
458
+ declare function safe<A, B, C, D, E, F, G>(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): G | Extract<A | B | C | D | E | F, null | undefined>;
459
+ declare function safe<A, B, C, D, E, F, G, H>(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): H | Extract<A | B | C | D | E | F | G, null | undefined>;
460
+ 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>;
461
+ 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>;
462
+ 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>;
463
+ declare function async<A>(a: A | Promise<A>): Promise<A>;
464
+ declare function async<A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
465
+ declare function async<A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
466
+ 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>;
467
+ 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>;
468
+ 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>;
469
+ 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>;
470
+ 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>;
471
+ 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>;
472
+ 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>;
473
+ 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>;
353
474
  /**
354
475
  * Pipes a value through a series of functions from left to right.
355
476
  * Each function receives the output of the previous function.
@@ -399,6 +520,73 @@ declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B)
399
520
  declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
400
521
  declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
401
522
  declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
523
+ declare namespace pipe {
524
+ export var when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
525
+ export var unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
526
+ export var either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
527
+ export var struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
528
+ export var safe: {
529
+ <A>(a: A): A;
530
+ <A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
531
+ <A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
532
+ <A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
533
+ <A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
534
+ <A, B, C, D, E, F>(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): F | Extract<A | B | C | D | E, null | undefined>;
535
+ <A, B, C, D, E, F, G>(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): G | Extract<A | B | C | D | E | F, null | undefined>;
536
+ <A, B, C, D, E, F, G, H>(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): H | Extract<A | B | C | D | E | F | G, null | undefined>;
537
+ <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>;
538
+ <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>;
539
+ <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>;
540
+ };
541
+ export var async: {
542
+ <A>(a: A | Promise<A>): Promise<A>;
543
+ <A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
544
+ <A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
545
+ <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>;
546
+ <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>;
547
+ <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>;
548
+ <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>;
549
+ <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>;
550
+ <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>;
551
+ <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>;
552
+ <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>;
553
+ };
554
+ var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
555
+ export { _a as try };
556
+ }
557
+ interface pipe {
558
+ /**
559
+ * Executes a function on the piped value if a predicate is met, otherwise returns the value unchanged.
560
+ */
561
+ readonly when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
562
+ /**
563
+ * Executes a function on the piped value if a predicate is NOT met, otherwise returns the value unchanged.
564
+ */
565
+ readonly unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
566
+ /**
567
+ * Executes one of two functions based on a predicate, acting as a functional if-else/ternary helper.
568
+ */
569
+ readonly either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
570
+ /**
571
+ * Creates a pipeline step that wraps a throwing function in a try/catch, returning a fallback value if an error occurs.
572
+ */
573
+ readonly try: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
574
+ /**
575
+ * Builds an object by applying a record of field-level transformer functions to the piped input.
576
+ */
577
+ readonly struct: <A, R extends Record<string, unknown>>(fields: {
578
+ [K in keyof R]: (a: A) => R[K];
579
+ }) => (a: A) => R;
580
+ /**
581
+ * Pipes a value through a sequence of operations, short-circuiting and propagating
582
+ * null or undefined immediately if any intermediate step evaluates to nil.
583
+ */
584
+ readonly safe: typeof safe;
585
+ /**
586
+ * Pipes a value through a sequence of operations, supporting asynchronous transitions at any step.
587
+ */
588
+ readonly async: typeof async;
589
+ }
402
590
 
403
591
  /**
404
592
  * Executes a side effect function and returns the original value unchanged.
@@ -485,4 +673,4 @@ declare const uncurry3: <A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D) => (a:
485
673
  */
486
674
  declare const uncurry4: <A, B, C, D, E>(f: (a: A) => (b: B) => (c: C) => (d: D) => E) => (a: A, b: B, c: C, d: D) => E;
487
675
 
488
- export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 };
676
+ export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 };
package/dist/composition.d.ts CHANGED
@@ -120,6 +120,26 @@ declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A
120
120
  */
121
121
  declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
122
122
 
123
+ declare function safe$1<A, B>(ab: (a: NonNullable<A>) => B): (a: A) => B | Extract<A, null | undefined>;
124
+ declare function safe$1<A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
125
+ declare function safe$1<A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
126
+ declare function safe$1<A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
127
+ declare function safe$1<A, B, C, D, E, F>(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): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
128
+ declare function safe$1<A, B, C, D, E, F, G>(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): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
129
+ declare function safe$1<A, B, C, D, E, F, G, H>(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): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
130
+ 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>;
131
+ 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>;
132
+ 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>;
133
+ declare function async$1<A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
134
+ 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>;
135
+ 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>;
136
+ 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>;
137
+ 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>;
138
+ 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>;
139
+ 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>;
140
+ 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>;
141
+ 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>;
142
+ 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>;
123
143
  /**
124
144
  * Composes functions from left to right, returning a new function.
125
145
  * Unlike `pipe`, `flow` doesn't take an initial value - it creates
@@ -170,6 +190,71 @@ declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H>(ab:
170
190
  declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (...a: A) => I;
171
191
  declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;
172
192
  declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J, K>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): (...a: A) => K;
193
+ declare namespace flow {
194
+ export var when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
195
+ export var unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
196
+ export var either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
197
+ export var struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
198
+ export var safe: {
199
+ <A, B>(ab: (a: NonNullable<A>) => B): (a: A) => B | Extract<A, null | undefined>;
200
+ <A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
201
+ <A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
202
+ <A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
203
+ <A, B, C, D, E, F>(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): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
204
+ <A, B, C, D, E, F, G>(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): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
205
+ <A, B, C, D, E, F, G, H>(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): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
206
+ <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>;
207
+ <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>;
208
+ <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>;
209
+ };
210
+ export var async: {
211
+ <A, B>(ab: (a: A) => B | Promise<B>): (a: A | Promise<A>) => Promise<B>;
212
+ <A, B, C>(ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): (a: A | Promise<A>) => Promise<C>;
213
+ <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>;
214
+ <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>;
215
+ <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>;
216
+ <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>;
217
+ <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>;
218
+ <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>;
219
+ <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>;
220
+ <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>;
221
+ };
222
+ var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
223
+ export { _a as try };
224
+ }
225
+ interface flow {
226
+ /**
227
+ * Executes a function on the piped value if a predicate is met, otherwise returns the value unchanged.
228
+ */
229
+ readonly when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
230
+ /**
231
+ * Executes a function on the piped value if a predicate is NOT met, otherwise returns the value unchanged.
232
+ */
233
+ readonly unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
234
+ /**
235
+ * Executes one of two functions based on a predicate, acting as a functional if-else/ternary helper.
236
+ */
237
+ readonly either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
238
+ /**
239
+ * Creates a pipeline step that wraps a throwing function in a try/catch, returning a fallback value if an error occurs.
240
+ */
241
+ readonly try: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
242
+ /**
243
+ * Builds an object by applying a record of field-level transformer functions to the piped input.
244
+ */
245
+ readonly struct: <A, R extends Record<string, unknown>>(fields: {
246
+ [K in keyof R]: (a: A) => R[K];
247
+ }) => (a: A) => R;
248
+ /**
249
+ * Pipes a value through a sequence of operations, short-circuiting and propagating
250
+ * null or undefined immediately if any intermediate step evaluates to nil.
251
+ */
252
+ readonly safe: typeof safe$1;
253
+ /**
254
+ * Pipes a value through a sequence of operations, supporting asynchronous transitions at any step.
255
+ */
256
+ readonly async: typeof async$1;
257
+ }
173
258
 
174
259
  /**
175
260
  * Returns the value unchanged. The identity function.
@@ -246,6 +331,20 @@ declare const or: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean
246
331
  * ```
247
332
  */
248
333
  declare const once: <A>(f: () => A) => () => A;
334
+ /**
335
+ * Returns a fallback value if the input is null or undefined; otherwise returns the input value.
336
+ * Highly useful as a data-last default value step inside pipelines.
337
+ *
338
+ * @example
339
+ * ```ts
340
+ * const getName = flow(
341
+ * (u: { name?: string | null }) => u.name,
342
+ * defaultTo("Guest"),
343
+ * name => name.toUpperCase()
344
+ * ); // returns string
345
+ * ```
346
+ */
347
+ declare const defaultTo: <B>(fallback: B) => <A>(a: A) => NonNullable<A> | B;
249
348
 
250
349
  /**
251
350
  * Applies an input to an array of functions and collects the results into a tuple.
@@ -350,6 +449,28 @@ declare const not: <A extends ReadonlyArray<unknown>>(predicate: (...args: A) =>
350
449
  */
351
450
  declare const on: <A, B, C>(f: (b1: B, b2: B) => C, g: (a: A) => B) => (a: A, b: A) => C;
352
451
 
452
+ declare function safe<A>(a: A): A;
453
+ declare function safe<A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
454
+ declare function safe<A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
455
+ declare function safe<A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
456
+ declare function safe<A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
457
+ declare function safe<A, B, C, D, E, F>(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): F | Extract<A | B | C | D | E, null | undefined>;
458
+ declare function safe<A, B, C, D, E, F, G>(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): G | Extract<A | B | C | D | E | F, null | undefined>;
459
+ declare function safe<A, B, C, D, E, F, G, H>(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): H | Extract<A | B | C | D | E | F | G, null | undefined>;
460
+ 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>;
461
+ 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>;
462
+ 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>;
463
+ declare function async<A>(a: A | Promise<A>): Promise<A>;
464
+ declare function async<A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
465
+ declare function async<A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
466
+ 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>;
467
+ 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>;
468
+ 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>;
469
+ 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>;
470
+ 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>;
471
+ 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>;
472
+ 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>;
473
+ 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>;
353
474
  /**
354
475
  * Pipes a value through a series of functions from left to right.
355
476
  * Each function receives the output of the previous function.
@@ -399,6 +520,73 @@ declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B)
399
520
  declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
400
521
  declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
401
522
  declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
523
+ declare namespace pipe {
524
+ export var when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
525
+ export var unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
526
+ export var either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
527
+ export var struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
528
+ export var safe: {
529
+ <A>(a: A): A;
530
+ <A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
531
+ <A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
532
+ <A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
533
+ <A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
534
+ <A, B, C, D, E, F>(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): F | Extract<A | B | C | D | E, null | undefined>;
535
+ <A, B, C, D, E, F, G>(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): G | Extract<A | B | C | D | E | F, null | undefined>;
536
+ <A, B, C, D, E, F, G, H>(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): H | Extract<A | B | C | D | E | F | G, null | undefined>;
537
+ <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>;
538
+ <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>;
539
+ <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>;
540
+ };
541
+ export var async: {
542
+ <A>(a: A | Promise<A>): Promise<A>;
543
+ <A, B>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>): Promise<B>;
544
+ <A, B, C>(a: A | Promise<A>, ab: (a: A) => B | Promise<B>, bc: (b: B) => C | Promise<C>): Promise<C>;
545
+ <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>;
546
+ <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>;
547
+ <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>;
548
+ <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>;
549
+ <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>;
550
+ <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>;
551
+ <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>;
552
+ <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>;
553
+ };
554
+ var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
555
+ export { _a as try };
556
+ }
557
+ interface pipe {
558
+ /**
559
+ * Executes a function on the piped value if a predicate is met, otherwise returns the value unchanged.
560
+ */
561
+ readonly when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
562
+ /**
563
+ * Executes a function on the piped value if a predicate is NOT met, otherwise returns the value unchanged.
564
+ */
565
+ readonly unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
566
+ /**
567
+ * Executes one of two functions based on a predicate, acting as a functional if-else/ternary helper.
568
+ */
569
+ readonly either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
570
+ /**
571
+ * Creates a pipeline step that wraps a throwing function in a try/catch, returning a fallback value if an error occurs.
572
+ */
573
+ readonly try: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
574
+ /**
575
+ * Builds an object by applying a record of field-level transformer functions to the piped input.
576
+ */
577
+ readonly struct: <A, R extends Record<string, unknown>>(fields: {
578
+ [K in keyof R]: (a: A) => R[K];
579
+ }) => (a: A) => R;
580
+ /**
581
+ * Pipes a value through a sequence of operations, short-circuiting and propagating
582
+ * null or undefined immediately if any intermediate step evaluates to nil.
583
+ */
584
+ readonly safe: typeof safe;
585
+ /**
586
+ * Pipes a value through a sequence of operations, supporting asynchronous transitions at any step.
587
+ */
588
+ readonly async: typeof async;
589
+ }
402
590
 
403
591
  /**
404
592
  * Executes a side effect function and returns the original value unchanged.
@@ -485,4 +673,4 @@ declare const uncurry3: <A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D) => (a:
485
673
  */
486
674
  declare const uncurry4: <A, B, C, D, E>(f: (a: A) => (b: B) => (c: C) => (d: D) => E) => (a: A, b: B, c: C, d: D) => E;
487
675
 
488
- export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 };
676
+ export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 };