@nlozgachev/pipelined 0.64.0 → 0.65.0

package/dist/composition.mjs

@@ -1,610 +1,728 @@
-// src/Composition/compose.ts
+import { Duration } from "./types.mjs";
+import { inspect } from "node:util";
+//#region src/Composition/compose.ts
 function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
-  const len = arguments.length;
-  switch (len) {
-    case 1: {
-      return f0;
-    }
-    case 2: {
-      return function() {
-        return f0(f1.apply(this, arguments));
-      };
-    }
-    case 3: {
-      return function() {
-        return f0(f1(f2.apply(this, arguments)));
-      };
-    }
-    case 4: {
-      return function() {
-        return f0(f1(f2(f3.apply(this, arguments))));
-      };
-    }
-    case 5: {
-      return function() {
-        return f0(f1(f2(f3(f4.apply(this, arguments)))));
-      };
-    }
-    case 6: {
-      return function() {
-        return f0(f1(f2(f3(f4(f5.apply(this, arguments))))));
-      };
-    }
-    case 7: {
-      return function() {
-        return f0(f1(f2(f3(f4(f5(f6.apply(this, arguments)))))));
-      };
-    }
-    case 8: {
-      return function() {
-        return f0(f1(f2(f3(f4(f5(f6(f7.apply(this, arguments))))))));
-      };
-    }
-    case 9: {
-      return function() {
-        return f0(f1(f2(f3(f4(f5(f6(f7(f8.apply(this, arguments)))))))));
-      };
-    }
-    case 10: {
-      return function() {
-        return f0(f1(f2(f3(f4(f5(f6(f7(f8(f9.apply(this, arguments))))))))));
-      };
-    }
-  }
+	switch (arguments.length) {
+		case 1: return f0;
+		case 2: return function() {
+			return f0(f1.apply(this, arguments));
+		};
+		case 3: return function() {
+			return f0(f1(f2.apply(this, arguments)));
+		};
+		case 4: return function() {
+			return f0(f1(f2(f3.apply(this, arguments))));
+		};
+		case 5: return function() {
+			return f0(f1(f2(f3(f4.apply(this, arguments)))));
+		};
+		case 6: return function() {
+			return f0(f1(f2(f3(f4(f5.apply(this, arguments))))));
+		};
+		case 7: return function() {
+			return f0(f1(f2(f3(f4(f5(f6.apply(this, arguments)))))));
+		};
+		case 8: return function() {
+			return f0(f1(f2(f3(f4(f5(f6(f7.apply(this, arguments))))))));
+		};
+		case 9: return function() {
+			return f0(f1(f2(f3(f4(f5(f6(f7(f8.apply(this, arguments)))))))));
+		};
+		case 10: return function() {
+			return f0(f1(f2(f3(f4(f5(f6(f7(f8(f9.apply(this, arguments))))))))));
+		};
+	}
 }
-
-// src/Composition/converge.ts
+//#endregion
+//#region src/Composition/converge.ts
 function converge(f, transformers) {
-  return (a) => f(...transformers.map((t) => t(a)));
+	return (a) => f(...transformers.map((t) => t(a)));
 }
-
-// src/Composition/curry.ts
-var curry = (f) => (a) => (b) => f(a, b);
-var curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
-var curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);
-
-// src/Composition/flip.ts
-var flip = (f) => (b) => (a) => f(a)(b);
-
-// src/Composition/flow.ts
+//#endregion
+//#region src/Composition/curry.ts
+/**
+* Converts a multi-argument function into a curried function.
+* The inverse of `uncurry`.
+*
+* @example
+* ```ts
+* const add = (a: number, b: number) => a + b;
+* const curriedAdd = curry(add);
+* curriedAdd(1)(2); // 3
+*
+* // Partial application
+* const addTen = curriedAdd(10);
+* addTen(5); // 15
+* ```
+*
+* @see {@link uncurry} for the inverse operation
+* @see {@link curry3} for 3-argument functions
+* @see {@link curry4} for 4-argument functions
+*/
+const curry = (f) => (a) => (b) => f(a, b);
+/**
+* Converts a 3-argument function into a curried function.
+*
+* @example
+* ```ts
+* const add3 = (a: number, b: number, c: number) => a + b + c;
+* const curriedAdd3 = curry3(add3);
+* curriedAdd3(1)(2)(3); // 6
+* ```
+*/
+const curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
+/**
+* Converts a 4-argument function into a curried function.
+*
+* @example
+* ```ts
+* const add4 = (a: number, b: number, c: number, d: number) => a + b + c + d;
+* const curriedAdd4 = curry4(add4);
+* curriedAdd4(1)(2)(3)(4); // 10
+* ```
+*/
+const curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);
+//#endregion
+//#region src/Composition/flip.ts
+/**
+* Flips the order of arguments for a curried binary function.
+* Converts a data-last function to data-first.
+*
+* @example
+* ```ts
+* // Original data-last (for pipe)
+* pipe(
+*   Maybe.make.some(5),
+*   Maybe.map(n => n * 2)
+* ); // Some(10)
+*
+* // Flipped to data-first
+* const mapFirst = flip(Maybe.map);
+* mapFirst(Maybe.make.some(5))(n => n * 2); // Some(10)
+* ```
+*
+* @see {@link uncurry} for converting curried functions to multi-argument functions
+*/
+const flip = (f) => (b) => (a) => f(a)(b);
+//#endregion
+//#region src/Composition/flow.ts
 function flow(ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
-  const len = arguments.length;
-  switch (len) {
-    case 0: {
-      return function(...args) {
-        return args[0];
-      };
-    }
-    case 1: {
-      return ab;
-    }
-    case 2: {
-      return function() {
-        return bc(ab.apply(this, arguments));
-      };
-    }
-    case 3: {
-      return function() {
-        return cd(bc(ab.apply(this, arguments)));
-      };
-    }
-    case 4: {
-      return function() {
-        return de(cd(bc(ab.apply(this, arguments))));
-      };
-    }
-    case 5: {
-      return function() {
-        return ef(de(cd(bc(ab.apply(this, arguments)))));
-      };
-    }
-    case 6: {
-      return function() {
-        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
-      };
-    }
-    case 7: {
-      return function() {
-        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
-      };
-    }
-    case 8: {
-      return function() {
-        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
-      };
-    }
-    case 9: {
-      return function() {
-        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
-      };
-    }
-    case 10: {
-      return function() {
-        return jk(ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))));
-      };
-    }
-  }
+	switch (arguments.length) {
+		case 0: return function(...args) {
+			return args[0];
+		};
+		case 1: return ab;
+		case 2: return function() {
+			return bc(ab.apply(this, arguments));
+		};
+		case 3: return function() {
+			return cd(bc(ab.apply(this, arguments)));
+		};
+		case 4: return function() {
+			return de(cd(bc(ab.apply(this, arguments))));
+		};
+		case 5: return function() {
+			return ef(de(cd(bc(ab.apply(this, arguments)))));
+		};
+		case 6: return function() {
+			return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+		};
+		case 7: return function() {
+			return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+		};
+		case 8: return function() {
+			return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+		};
+		case 9: return function() {
+			return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+		};
+		case 10: return function() {
+			return jk(ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))));
+		};
+	}
 }
-var when = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
-var unless = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
-var either = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
-var struct = (fields) => (a) => {
-  const result = {};
-  for (const key of Object.keys(fields)) {
-    result[key] = fields[key](a);
-  }
-  return result;
+const when$1 = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+const unless$1 = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+const either$1 = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+const struct$1 = (fields) => (a) => {
+	const result = {};
+	for (const key of Object.keys(fields)) result[key] = fields[key](a);
+	return result;
 };
-function safe(...fns) {
-  return (a) => {
-    let result = a;
-    if (result === null || result === void 0) {
-      return result;
-    }
-    for (const fn of fns) {
-      result = fn(result);
-      if (result === null || result === void 0) {
-        return result;
-      }
-    }
-    return result;
-  };
+function safe$1(...fns) {
+	return (a) => {
+		let result = a;
+		if (result === null || result === void 0) return result;
+		for (const fn of fns) {
+			result = fn(result);
+			if (result === null || result === void 0) return result;
+		}
+		return result;
+	};
 }
-function async(...fns) {
-  return async (a) => {
-    let result = await a;
-    for (const fn of fns) {
-      result = await fn(result);
-    }
-    return result;
-  };
+function async$2(...fns) {
+	return async (a) => {
+		let result = await a;
+		for (const fn of fns) result = await fn(result);
+		return result;
+	};
 }
-flow.when = when;
-flow.unless = unless;
-flow.either = either;
-flow.struct = struct;
-flow.safe = safe;
-flow.async = async;
+flow.when = when$1;
+flow.unless = unless$1;
+flow.either = either$1;
+flow.struct = struct$1;
+flow.safe = safe$1;
+flow.async = async$2;
 flow.try = (f, onError) => (a) => {
-  try {
-    return f(a);
-  } catch (error) {
-    return onError(error, a);
-  }
+	try {
+		return f(a);
+	} catch (error) {
+		return onError(error, a);
+	}
 };
-
-// src/Composition/fn.ts
-var identity = (a) => a;
-var constant = (a) => () => a;
-var constTrue = () => true;
-var constFalse = () => false;
-var constNull = () => null;
-var constUndefined = () => void 0;
-var constVoid = () => {
+//#endregion
+//#region src/Composition/fn.ts
+/**
+* Returns the value unchanged. The identity function.
+*
+* @example
+* ```ts
+* identity(42); // 42
+* pipe(Maybe.make.some(5), Maybe.fold(() => 0, identity)); // 5
+* ```
+*/
+const identity = (a) => a;
+/**
+* Creates a function that always returns the given value, ignoring its argument.
+*
+* @example
+* ```ts
+* const always42 = constant(42);
+* always42(); // 42
+* [1, 2, 3].map(constant("x")); // ["x", "x", "x"]
+* ```
+*/
+const constant = (a) => () => a;
+/**
+* Always returns `true`.
+*
+* @example
+* ```ts
+* constTrue(); // true
+* ```
+*/
+const constTrue = () => true;
+/**
+* Always returns `false`.
+*
+* @example
+* ```ts
+* constFalse(); // false
+* ```
+*/
+const constFalse = () => false;
+/**
+* Always returns `null`.
+*
+* @example
+* ```ts
+* constNull(); // null
+* ```
+*/
+const constNull = () => null;
+/**
+* Always returns `undefined`.
+*
+* @example
+* ```ts
+* constUndefined(); // undefined
+* ```
+*/
+const constUndefined = () => void 0;
+/**
+* Always returns `void`.
+*
+* @example
+* ```ts
+* constVoid(); // undefined
+* ```
+*/
+const constVoid = () => {};
+/**
+* Combines two predicates with logical AND.
+*
+* @example
+* ```ts
+* const isPositive = (n: number) => n > 0;
+* const isEven = (n: number) => n % 2 === 0;
+* const isPositiveEven = and(isPositive, isEven);
+*
+* isPositiveEven(4); // true
+* isPositiveEven(-2); // false
+* isPositiveEven(3); // false
+* ```
+*/
+const and = (p1, p2) => (...args) => p1(...args) && p2(...args);
+/**
+* Combines two predicates with logical OR.
+*
+* @example
+* ```ts
+* const isNegative = (n: number) => n < 0;
+* const isZero = (n: number) => n === 0;
+* const isNonPositive = or(isNegative, isZero);
+*
+* isNonPositive(-1); // true
+* isNonPositive(0); // true
+* isNonPositive(1); // false
+* ```
+*/
+const or = (p1, p2) => (...args) => p1(...args) || p2(...args);
+/**
+* Creates a function that executes at most once.
+* Subsequent calls return the cached result from the first execution.
+*
+* @example
+* ```ts
+* let count = 0;
+* const initOnce = once(() => { count++; return "initialized"; });
+*
+* initOnce(); // "initialized", count === 1
+* initOnce(); // "initialized", count === 1 (not called again)
+* ```
+*/
+const once = (f) => {
+	let called = false;
+	let result;
+	return () => {
+		if (!called) {
+			result = f();
+			called = true;
+		}
+		return result;
+	};
 };
-var and = (p1, p2) => (...args) => p1(...args) && p2(...args);
-var or = (p1, p2) => (...args) => p1(...args) || p2(...args);
-var once = (f) => {
-  let called = false;
-  let result;
-  return () => {
-    if (!called) {
-      result = f();
-      called = true;
-    }
-    return result;
-  };
-};
-var defaultTo = (fallback) => (a) => a === null || a === void 0 ? fallback : a;
-var tuple = (f) => (args) => f(...args);
-var untuple = (f) => (...args) => f(args);
-
-// src/Composition/juxt.ts
+/**
+* Returns a fallback value if the input is null or undefined; otherwise returns the input value.
+* Highly useful as a data-last default value step inside pipelines.
+*
+* @example
+* ```ts
+* const getName = flow(
+*   (u: { name?: string | null }) => u.name,
+*   defaultTo("Guest"),
+*   (name: string) => name.toUpperCase()
+* ); // returns string
+* ```
+*/
+const defaultTo = (fallback) => (a) => a === null || a === void 0 ? fallback : a;
+/**
+* Converts a function taking multiple arguments into a function taking a single tuple argument.
+*
+* @example
+* ```ts
+* const add = (a: number, b: number) => a + b;
+* const addTuple = tuple(add);
+* addTuple([2, 3]); // 5
+* ```
+*/
+const tuple = (f) => (args) => f(...args);
+/**
+* Converts a function taking a single tuple argument into a function taking multiple arguments.
+*
+* @example
+* ```ts
+* const addTuple = ([a, b]: readonly [number, number]) => a + b;
+* const add = untuple(addTuple);
+* add(2, 3); // 5
+* ```
+*/
+const untuple = (f) => (...args) => f(args);
+//#endregion
+//#region src/Composition/juxt.ts
 function juxt(fns) {
-  return (a) => fns.map((f) => f(a));
+	return (a) => fns.map((f) => f(a));
 }
-
-// src/Composition/memoize.ts
-var memoize = (f, options) => {
-  const cache = /* @__PURE__ */ new Map();
-  const keyFn = options?.key ?? ((a) => a);
-  const maxSize = options?.maxSize;
-  return (a) => {
-    const key = keyFn(a);
-    if (cache.has(key)) {
-      const cached = cache.get(key);
-      if (maxSize !== void 0) {
-        cache.delete(key);
-        cache.set(key, cached);
-      }
-      return cached;
-    }
-    const result = f(a);
-    cache.set(key, result);
-    if (maxSize !== void 0 && cache.size > maxSize) {
-      for (const k of cache.keys()) {
-        cache.delete(k);
-        break;
-      }
-    }
-    return result;
-  };
+//#endregion
+//#region src/Composition/memoize.ts
+/**
+* Creates a memoized version of a function that caches results.
+* Subsequent calls with the same argument return the cached result.
+*
+* By default, uses the argument directly as the cache key.
+* For complex arguments, provide a custom `keyFn` to generate cache keys.
+*
+* @example
+* ```ts
+* // Basic usage
+* const expensive = memoize((n: number) => {
+*   console.log("Computing...");
+*   return n * 2;
+* });
+*
+* expensive(5); // logs "Computing...", returns 10
+* expensive(5); // returns 10 (cached, no log)
+* expensive(3); // logs "Computing...", returns 6
+*
+* // With custom key function for objects
+* const fetchUser = memoize(
+*   (opts: { id: string }) => fetch(`/users/${opts.id}`),
+*   { key: (opts) => opts.id }
+* );
+* // With bounded cache size (LRU eviction)
+* const bounded = memoize(
+*   (n: number) => n * 2,
+*   { maxSize: 100 }
+* );
+* ```
+*/
+const memoize = (f, options) => {
+	const cache = /* @__PURE__ */ new Map();
+	const keyFn = options?.key ?? ((a) => a);
+	const maxSize = options?.maxSize;
+	return (a) => {
+		const key = keyFn(a);
+		if (cache.has(key)) {
+			const cached = cache.get(key);
+			if (maxSize !== void 0) {
+				cache.delete(key);
+				cache.set(key, cached);
+			}
+			return cached;
+		}
+		const result = f(a);
+		cache.set(key, result);
+		if (maxSize !== void 0 && cache.size > maxSize) for (const k of cache.keys()) {
+			cache.delete(k);
+			break;
+		}
+		return result;
+	};
 };
-var memoizeWeak = (f) => {
-  const cache = /* @__PURE__ */ new WeakMap();
-  return (a) => {
-    if (cache.has(a)) {
-      return cache.get(a);
-    }
-    const result = f(a);
-    cache.set(a, result);
-    return result;
-  };
+/**
+* Creates a memoized version of a function using WeakMap.
+* Only works with object arguments, but allows garbage collection
+* of cached values when keys are no longer referenced.
+*
+* @example
+* ```ts
+* type User = { id: number; name: string };
+* const expensiveOperation = (u: User) => u.name.toUpperCase();
+*
+* const processUser = memoizeWeak((user: User) => {
+*   return expensiveOperation(user);
+* });
+*
+* const user = { id: 1, name: "Alice" };
+* processUser(user); // computed
+* processUser(user); // cached
+* // When `user` is garbage collected, cached result is too
+* ```
+*/
+const memoizeWeak = (f) => {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (a) => {
+		if (cache.has(a)) return cache.get(a);
+		const result = f(a);
+		cache.set(a, result);
+		return result;
+	};
 };
-
-// src/Composition/not.ts
-var not = (predicate) => (...args) => !predicate(...args);
-
-// src/Composition/on.ts
-var on = (f, g) => (a, b) => f(g(a), g(b));
-
-// src/Composition/pipe.ts
+//#endregion
+//#region src/Composition/not.ts
+/**
+* Negates a predicate function.
+* Returns a new predicate that returns true when the original returns false, and vice versa.
+*
+* @example
+* ```ts
+* const isEven = (n: number) => n % 2 === 0;
+* const isOdd = not(isEven);
+*
+* isOdd(3); // true
+* isOdd(4); // false
+*
+* // With array methods
+* const numbers = [1, 2, 3, 4, 5];
+* numbers.filter(not(isEven)); // [1, 3, 5]
+*
+* // In pipelines
+* const users = [{ name: "Alice", isAdmin: false }, { name: "Bob", isAdmin: true }];
+* const isAdmin = (u: { name: string; isAdmin: boolean }) => u.isAdmin;
+* pipe(
+*   users,
+*   Arr.filter(not(isAdmin)),
+*   Arr.map((u: { name: string; isAdmin: boolean }) => u.name)
+* );
+* ```
+*/
+const not = (predicate) => (...args) => !predicate(...args);
+//#endregion
+//#region src/Composition/on.ts
+/**
+* Applies a projection to both arguments of a binary function before calling it.
+* Most useful for building comparators and equality checks over projected values.
+*
+* @example
+* ```ts
+* const byLength = on((a: number, b: number) => a - b, (s: string) => s.length);
+*
+* ["banana", "fig", "apple"].sort(byLength); // ["fig", "apple", "banana"]
+* ```
+*/
+const on = (f, g) => (a, b) => f(g(a), g(b));
+//#endregion
+//#region src/Composition/pipe.ts
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
-  switch (arguments.length) {
-    case 1: {
-      return a;
-    }
-    case 2: {
-      return ab(a);
-    }
-    case 3: {
-      return bc(ab(a));
-    }
-    case 4: {
-      return cd(bc(ab(a)));
-    }
-    case 5: {
-      return de(cd(bc(ab(a))));
-    }
-    case 6: {
-      return ef(de(cd(bc(ab(a)))));
-    }
-    case 7: {
-      return fg(ef(de(cd(bc(ab(a))))));
-    }
-    case 8: {
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
-    }
-    case 9: {
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    }
-    case 10: {
-      return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
-    }
-    case 11: {
-      return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
-    }
-  }
+	switch (arguments.length) {
+		case 1: return a;
+		case 2: return ab(a);
+		case 3: return bc(ab(a));
+		case 4: return cd(bc(ab(a)));
+		case 5: return de(cd(bc(ab(a))));
+		case 6: return ef(de(cd(bc(ab(a)))));
+		case 7: return fg(ef(de(cd(bc(ab(a))))));
+		case 8: return gh(fg(ef(de(cd(bc(ab(a)))))));
+		case 9: return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+		case 10: return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
+		case 11: return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
+	}
 }
-var when2 = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
-var unless2 = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
-var either2 = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
-var struct2 = (fields) => (a) => {
-  const result = {};
-  for (const key of Object.keys(fields)) {
-    result[key] = fields[key](a);
-  }
-  return result;
+const when = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+const unless = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+const either = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+const struct = (fields) => (a) => {
+	const result = {};
+	for (const key of Object.keys(fields)) result[key] = fields[key](a);
+	return result;
 };
-function safe2(a, ...fns) {
-  let result = a;
-  if (result === null || result === void 0) {
-    return result;
-  }
-  for (const fn of fns) {
-    result = fn(result);
-    if (result === null || result === void 0) {
-      return result;
-    }
-  }
-  return result;
+function safe(a, ...fns) {
+	let result = a;
+	if (result === null || result === void 0) return result;
+	for (const fn of fns) {
+		result = fn(result);
+		if (result === null || result === void 0) return result;
+	}
+	return result;
 }
-async function async2(a, ...fns) {
-  let result = await a;
-  for (const fn of fns) {
-    result = await fn(result);
-  }
-  return result;
+async function async$1(a, ...fns) {
+	let result = await a;
+	for (const fn of fns) result = await fn(result);
+	return result;
 }
-pipe.when = when2;
-pipe.unless = unless2;
-pipe.either = either2;
-pipe.struct = struct2;
-pipe.safe = safe2;
-pipe.async = async2;
+pipe.when = when;
+pipe.unless = unless;
+pipe.either = either;
+pipe.struct = struct;
+pipe.safe = safe;
+pipe.async = async$1;
 pipe.try = (f, onError) => (a) => {
-  try {
-    return f(a);
-  } catch (error) {
-    return onError(error, a);
-  }
-};
-
-// src/Composition/tap.ts
-import { inspect as nodeInspect } from "util";
-
-// src/Types/Brand.ts
-var Brand = {
-  /**
-   * Returns a constructor that wraps a value of type T in brand K.
-   * The resulting function performs an unchecked cast — only use when the raw
-   * value is known to satisfy the brand's invariants.
-   *
-   * @example
-   * ```ts
-   * type PositiveNumber = Brand<"PositiveNumber", number>;
-   * const toPositiveNumber = Brand.wrap<"PositiveNumber", number>();
-   *
-   * const n: PositiveNumber = toPositiveNumber(42);
-   * ```
-   */
-  wrap: () => (value) => value,
-  /**
-   * Strips the brand and returns the underlying value.
-   * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
-   *
-   * @example
-   * ```ts
-   * type UserId = Brand<"UserId", string>;
-   * const toUserId = Brand.wrap<"UserId", string>();
-   * const userId: UserId = toUserId("user-123");
-   * const raw: string = Brand.unwrap(userId); // "user-123"
-   * ```
-   */
-  unwrap: (branded) => branded
+	try {
+		return f(a);
+	} catch (error) {
+		return onError(error, a);
+	}
 };
-
-// src/Types/Duration.ts
-var wrap = Brand.wrap();
-var Duration = {
-  /**
-   * Creates a Duration from milliseconds.
-   *
-   * @example
-   * ```ts
-   * Duration.milliseconds(500); // 500ms Duration
-   * ```
-   */
-  milliseconds: (ms) => wrap(ms),
-  /**
-   * Creates a Duration from seconds.
-   *
-   * @example
-   * ```ts
-   * Duration.seconds(2); // 2000ms Duration
-   * ```
-   */
-  seconds: (s) => wrap(s * 1e3),
-  /**
-   * Creates a Duration from minutes.
-   *
-   * @example
-   * ```ts
-   * Duration.minutes(5); // 300000ms Duration
-   * ```
-   */
-  minutes: (m) => wrap(m * 60 * 1e3),
-  /**
-   * Creates a Duration from hours.
-   *
-   * @example
-   * ```ts
-   * Duration.hours(1); // 3600000ms Duration
-   * ```
-   */
-  hours: (h) => wrap(h * 60 * 60 * 1e3),
-  /**
-   * Creates a Duration from days.
-   *
-   * @example
-   * ```ts
-   * Duration.days(1); // 86400000ms Duration
-   * ```
-   */
-  days: (d) => wrap(d * 24 * 60 * 60 * 1e3),
-  // --- to ---
-  to: {
-    /**
-     * Converts a Duration back to raw milliseconds.
-     *
-     * @example
-     * ```ts
-     * Duration.to.milliseconds(Duration.seconds(2)); // 2000
-     * ```
-     */
-    milliseconds: (d) => Brand.unwrap(d),
-    /**
-     * Converts a Duration to seconds.
-     *
-     * @example
-     * ```ts
-     * Duration.to.seconds(Duration.milliseconds(2500)); // 2.5
-     * ```
-     */
-    seconds: (d) => Brand.unwrap(d) / 1e3,
-    /**
-     * Converts a Duration to minutes.
-     *
-     * @example
-     * ```ts
-     * Duration.to.minutes(Duration.seconds(120)); // 2
-     * ```
-     */
-    minutes: (d) => Brand.unwrap(d) / (60 * 1e3),
-    /**
-     * Converts a Duration to hours.
-     *
-     * @example
-     * ```ts
-     * Duration.to.hours(Duration.minutes(90)); // 1.5
-     * ```
-     */
-    hours: (d) => Brand.unwrap(d) / (60 * 60 * 1e3),
-    /**
-     * Converts a Duration to days.
-     *
-     * @example
-     * ```ts
-     * Duration.to.days(Duration.hours(36)); // 1.5
-     * ```
-     */
-    days: (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3)
-  },
-  /**
-   * Adds two Durations together.
-   *
-   * @example
-   * ```ts
-   * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
-   * ```
-   */
-  add: (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other)),
-  /**
-   * Subtracts the other Duration from this one.
-   *
-   * @example
-   * ```ts
-   * pipe(Duration.seconds(1), Duration.subtract(Duration.milliseconds(500))); // 500ms
-   * ```
-   */
-  subtract: (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other))
-};
-
-// src/Composition/tap.ts
+//#endregion
+//#region src/Composition/tap.ts
+/**
+* Executes a side effect function and returns the original value unchanged.
+* Useful for logging, debugging, or other side effects within a pipeline.
+*
+* @example
+* ```ts
+* // Debugging a pipeline
+* pipe(
+*   Maybe.make.some(5),
+*   tap(x => console.log("Before map:", x)),
+*   Maybe.map(n => n * 2),
+*   tap(x => console.log("After map:", x)),
+*   Maybe.getOrElse(() => 0)
+* );
+* // logs: "Before map: { kind: 'Some', value: 5 }"
+* // logs: "After map: { kind: 'Some', value: 10 }"
+* // returns: 10
+*
+* // Collecting intermediate values
+* const values: number[] = [];
+* pipe(
+*   [1, 2, 3],
+*   arr => arr.map(n => n * 2),
+*   tap(arr => values.push(...arr))
+* );
+* ```
+*
+* @see {@link Maybe.tap} for Maybe-specific tap that only runs on Some
+*/
 function tap(f) {
-  return (a) => {
-    f(a);
-    return a;
-  };
+	return (a) => {
+		f(a);
+		return a;
+	};
 }
-var log = (options) => (a) => {
-  const logger = options?.logger ?? console.log;
-  const formatter = options?.formatter ?? ((val) => {
-    try {
-      return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
-    } catch {
-      return String(val);
-    }
-  });
-  const formatted = formatter(a);
-  if (options?.label !== void 0) {
-    logger(`[${options.label}]: ${formatted}`);
-  } else {
-    logger(formatted);
-  }
-  return a;
+/**
+* Logs the piped value to the console or a custom logger, returning the value unchanged.
+*
+* @example
+* ```ts
+* pipe(
+*   42,
+*   tap.log(), // logs: 42
+*   tap.log({ label: "Count" }) // logs: [Count]: 42
+* );
+* ```
+*/
+const log = (options) => (a) => {
+	const logger = options?.logger ?? console.log;
+	const formatted = (options?.formatter ?? ((val) => {
+		try {
+			return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
+		} catch {
+			return String(val);
+		}
+	}))(a);
+	if (options?.label !== void 0) logger(`[${options.label}]: ${formatted}`);
+	else logger(formatted);
+	return a;
 };
-var inspect = (options) => (a) => {
-  const label = options?.label;
-  const depth = options?.depth ?? null;
-  const colors = options?.colors ?? true;
-  let formatted;
-  if (typeof nodeInspect === "function") {
-    formatted = nodeInspect(a, { depth, colors });
-  } else {
-    try {
-      formatted = JSON.stringify(a, null, 2);
-    } catch {
-      formatted = String(a);
-    }
-  }
-  if (label !== void 0) {
-    console.log(`[${label}]: ${formatted}`);
-  } else {
-    console.log(formatted);
-  }
-  return a;
+/**
+* Performs a deep structured inspect formatting on the piped value, returning it unchanged.
+* In Node.js environments, this utilizes Node's `node:util` `inspect` utility.
+*
+* @example
+* ```ts
+* pipe(
+*   { user: { name: "Alice", details: { age: 30 } } },
+*   tap.inspect({ label: "User Object", depth: 2 })
+* );
+* ```
+*/
+const inspect$1 = (options) => (a) => {
+	const label = options?.label;
+	const depth = options?.depth ?? null;
+	const colors = options?.colors ?? true;
+	let formatted;
+	if (typeof inspect === "function") formatted = inspect(a, {
+		depth,
+		colors
+	});
+	else try {
+		formatted = JSON.stringify(a, null, 2);
+	} catch {
+		formatted = String(a);
+	}
+	if (label !== void 0) console.log(`[${label}]: ${formatted}`);
+	else console.log(formatted);
+	return a;
 };
-var async3 = (fn, options) => (a) => {
-  const onError = options?.onError ?? console.error;
-  Promise.resolve(fn(a)).catch((err) => {
-    onError(err);
-  });
-  return a;
+/**
+* Triggers a fire-and-forget asynchronous side effect in the background,
+* returning the piped value immediately and synchronously.
+* Any errors thrown by the async function are caught and forwarded to `onError`.
+*
+* @example
+* ```ts
+* const user = { id: 1 };
+* const saveToDatabase = async (u: typeof user) => {};
+* const logError = (err: unknown) => console.error(err);
+*
+* pipe(
+*   user,
+*   tap.async(async (u) => {
+*     await saveToDatabase(u);
+*   }, { onError: (err) => logError(err) })
+* );
+* ```
+*/
+const async = (fn, options) => (a) => {
+	const onError = options?.onError ?? console.error;
+	Promise.resolve(fn(a)).catch((err) => {
+		onError(err);
+	});
+	return a;
 };
-var time = (fn, config) => (a) => {
-  const start = performance.now();
-  const triggerFinish = (duration) => {
-    if (config.label !== void 0) {
-      console.log(`[${config.label}]: ${Duration.to.milliseconds(duration)}ms`);
-    } else {
-      config.onFinish(duration);
-    }
-  };
-  try {
-    const res = fn(a);
-    if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
-      res.then(() => {
-        const duration = Duration.milliseconds(performance.now() - start);
-        triggerFinish(duration);
-      }, () => {
-        const duration = Duration.milliseconds(performance.now() - start);
-        triggerFinish(duration);
-      });
-    } else {
-      const duration = Duration.milliseconds(performance.now() - start);
-      triggerFinish(duration);
-    }
-  } catch (err) {
-    const duration = Duration.milliseconds(performance.now() - start);
-    triggerFinish(duration);
-    throw err;
-  }
-  return a;
+/**
+* Runs a function and measures its execution duration, returning the value unchanged.
+* Supports both synchronous and asynchronous functions. If the timed function returns
+* a Promise, duration measurement resolves asynchronously upon resolution/rejection.
+*
+* @example
+* ```ts
+* const data = [1, 2, 3];
+* const processData = (d: typeof data) => d.map(n => n * 2);
+* const fetchData = async (d: typeof data) => d.length;
+* const metrics = { histogram: (name: string, ms: number) => {} };
+*
+* // Time a synchronous computation
+* pipe(
+*   data,
+*   tap.time(processData, { label: "sync-process" })
+* );
+*
+* // Time an asynchronous fetch with custom metrics callback
+* pipe(
+*   data,
+*   tap.time(fetchData, {
+*     onFinish: (dur) => metrics.histogram("api.time", Duration.to.milliseconds(dur))
+*   })
+* );
+* ```
+*/
+const time = (fn, config) => (a) => {
+	const start = performance.now();
+	const triggerFinish = (duration) => {
+		if (config.label !== void 0) console.log(`[${config.label}]: ${Duration.to.milliseconds(duration)}ms`);
+		else config.onFinish(duration);
+	};
+	try {
+		const res = fn(a);
+		if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") res.then(() => {
+			const duration = Duration.milliseconds(performance.now() - start);
+			triggerFinish(duration);
+		}, () => {
+			const duration = Duration.milliseconds(performance.now() - start);
+			triggerFinish(duration);
+		});
+		else triggerFinish(Duration.milliseconds(performance.now() - start));
+	} catch (err) {
+		triggerFinish(Duration.milliseconds(performance.now() - start));
+		throw err;
+	}
+	return a;
 };
 tap.log = log;
-tap.inspect = inspect;
-tap.async = async3;
+tap.inspect = inspect$1;
+tap.async = async;
 tap.time = time;
-
-// src/Composition/uncurry.ts
+//#endregion
+//#region src/Composition/uncurry.ts
 function uncurry(f) {
-  return (...args) => {
-    const inner = f(...args.slice(0, f.length));
-    return inner.length === 0 ? inner() : inner(...args.slice(f.length));
-  };
+	return (...args) => {
+		const inner = f(...args.slice(0, f.length));
+		return inner.length === 0 ? inner() : inner(...args.slice(f.length));
+	};
 }
-var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
-var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
-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,
-  tuple,
-  uncurry,
-  uncurry3,
-  uncurry4,
-  untuple
-};
+/**
+* Converts a curried 3-argument function into a multi-argument function.
+*
+* @example
+* ```ts
+* const curriedAdd3 = (a: number) => (b: number) => (c: number) => a + b + c;
+* const add3 = uncurry3(curriedAdd3);
+* add3(1, 2, 3); // 6
+* ```
+*/
+const uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
+/**
+* Converts a curried 4-argument function into a multi-argument function.
+*
+* @example
+* ```ts
+* const curriedAdd4 = (a: number) => (b: number) => (c: number) => (d: number) => a + b + c + d;
+* const add4 = uncurry4(curriedAdd4);
+* add4(1, 2, 3, 4); // 10
+* ```
+*/
+const uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
+//#endregion
+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, tuple, uncurry, uncurry3, uncurry4, untuple };