@nlozgachev/pipelined 0.31.0 → 0.32.0

package/dist/{Task-BDcKwFAj.d.mts → Task-CJZfcOkO.d.mts}

@@ -1,57 +1,5 @@
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
-declare const _deferred: unique symbol;
-/**
- * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
- *
- * Two design choices work together to make the guarantee structural rather than documentary:
- *
- * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
- *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
- * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
- *   no second argument to pass, so chaining and `.catch()` are impossible.
- *
- * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
- * never reject.
- *
- * @example
- * ```ts
- * const value = await Deferred.fromPromise(Promise.resolve(42));
- * // value === 42
- * ```
- */
-type Deferred<A> = {
-    readonly [_deferred]: A;
-    readonly then: (onfulfilled: (value: A) => unknown) => void;
-};
-declare namespace Deferred {
-    /**
-     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
-     * `.catch()`, `.finally()`, and chainable `.then()`.
-     *
-     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
-     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
-     * handle operations that may fail before converting to a `Deferred`.
-     *
-     * @example
-     * ```ts
-     * const d = Deferred.fromPromise(Promise.resolve("hello"));
-     * const value = await d; // "hello"
-     * ```
-     */
-    const fromPromise: <A>(p: Promise<A>) => Deferred<A>;
-    /**
-     * Converts a `Deferred` back into a `Promise`.
-     *
-     * @example
-     * ```ts
-     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
-     * // p is Promise<42>
-     * ```
-     */
-    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
-}
-
 type WithKind<K extends string> = {
     readonly kind: K;
 };
@@ -536,6 +484,223 @@ declare namespace Maybe {
     const ap: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
 }
 
+declare const _deferred: unique symbol;
+/**
+ * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
+ *
+ * Two design choices work together to make the guarantee structural rather than documentary:
+ *
+ * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
+ *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
+ * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
+ *   no second argument to pass, so chaining and `.catch()` are impossible.
+ *
+ * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
+ * never reject.
+ *
+ * @example
+ * ```ts
+ * const value = await Deferred.fromPromise(Promise.resolve(42));
+ * // value === 42
+ * ```
+ */
+type Deferred<A> = {
+    readonly [_deferred]: A;
+    readonly then: (onfulfilled: (value: A) => unknown) => void;
+};
+declare namespace Deferred {
+    /**
+     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
+     * `.catch()`, `.finally()`, and chainable `.then()`.
+     *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.fromPromise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    const fromPromise: <A>(p: Promise<A>) => Deferred<A>;
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
+}
+
+/**
+ * A function that checks whether two values of type `A` are equal.
+ * Use built-in instances (`Equality.string`, `Equality.number`, etc.) as starting points,
+ * then adapt them with `Equality.by` and combine them with `Equality.and`.
+ *
+ * @example
+ * ```ts
+ * type User = { id: string; name: string };
+ * const byId = pipe(Equality.string, Equality.by((u: User) => u.id));
+ *
+ * pipe(users, Arr.uniqWith(byId));
+ * ```
+ */
+type Equality<A> = (a: A, b: A) => boolean;
+declare namespace Equality {
+    /**
+     * Equality for strings. Case-sensitive.
+     *
+     * @example
+     * ```ts
+     * Equality.string("hello", "hello"); // true
+     * Equality.string("hello", "Hello"); // false
+     * ```
+     */
+    const string: Equality<string>;
+    /**
+     * Equality for numbers. Uses strict equality.
+     *
+     * @example
+     * ```ts
+     * Equality.number(42, 42); // true
+     * ```
+     */
+    const number: Equality<number>;
+    /**
+     * Equality for booleans.
+     *
+     * @example
+     * ```ts
+     * Equality.boolean(true, true); // true
+     * ```
+     */
+    const boolean: Equality<boolean>;
+    /**
+     * Equality for `Date` values. Compares by numeric time value.
+     *
+     * @example
+     * ```ts
+     * Equality.date(new Date("2024-01-01"), new Date("2024-01-01")); // true
+     * ```
+     */
+    const date: Equality<Date>;
+    /**
+     * Lifts an element equality into an array equality. Two arrays are equal if they have the
+     * same length and every element pair is equal under `eq`.
+     *
+     * @example
+     * ```ts
+     * Equality.array(Equality.number)([1, 2, 3], [1, 2, 3]); // true
+     * ```
+     */
+    const array: <A>(eq: Equality<A>) => Equality<readonly A[]>;
+    /**
+     * Adapts an equality for type `A` into an equality for type `B` by extracting a field.
+     * Read as "equality by this field": `pipe(Equality.string, Equality.by(u => u.name))`.
+     *
+     * @example
+     * ```ts
+     * type Product = { id: string; price: number };
+     * const byId = pipe(Equality.string, Equality.by((p: Product) => p.id));
+     * byId({ id: "p1", price: 9 }, { id: "p1", price: 12 }); // true
+     * ```
+     */
+    const by: <A, B>(f: (b: B) => A) => (eq: Equality<A>) => Equality<B>;
+    /**
+     * Combines two equalities with logical AND. Both must pass for two values to be considered equal.
+     * Data-last: the first equality is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const exact = pipe(byName, Equality.and(byRole));
+     * exact(userA, userB); // true only if name AND role match
+     * ```
+     */
+    const and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
+}
+
+/**
+ * A function that orders two values of type `A`. Returns a negative number when `a` comes before
+ * `b`, a positive number when `a` comes after `b`, and `0` when they are equal.
+ *
+ * Compatible with `Array.prototype.sort` and `Arr.sortWith`.
+ *
+ * @example
+ * ```ts
+ * type Employee = { name: string; salary: number };
+ *
+ * const byName   = pipe(Ordering.string, Ordering.by((e: Employee) => e.name));
+ * const bySalary = pipe(Ordering.number, Ordering.by((e: Employee) => e.salary));
+ *
+ * pipe(employees, Arr.sortWith(pipe(byName, Ordering.thenBy(bySalary))));
+ * ```
+ */
+type Ordering<A> = (a: A, b: A) => number;
+declare namespace Ordering {
+    /**
+     * Alphabetical ordering for strings.
+     *
+     * @example
+     * ```ts
+     * Ordering.string("apple", "banana"); // negative
+     * ```
+     */
+    const string: Ordering<string>;
+    /**
+     * Numeric ordering. Equivalent to `(a, b) => a - b`.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
+     * ```
+     */
+    const number: Ordering<number>;
+    /**
+     * Ordering for `Date` values by numeric time value.
+     *
+     * @example
+     * ```ts
+     * pipe(dates, Arr.sortWith(Ordering.date)); // earliest first
+     * ```
+     */
+    const date: Ordering<Date>;
+    /**
+     * Flips the direction of an ordering.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortWith(Ordering.reverse(Ordering.number))); // [3, 2, 1]
+     * ```
+     */
+    const reverse: <A>(ord: Ordering<A>) => Ordering<A>;
+    /**
+     * Chains two orderings: the second is used only when the first returns `0`.
+     * Data-last: the first ordering is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const byDeptThenSalary = pipe(byDept, Ordering.thenBy(bySalary));
+     * ```
+     */
+    const thenBy: <A>(ord2: Ordering<A>) => (ord1: Ordering<A>) => Ordering<A>;
+    /**
+     * Adapts an ordering for type `A` into an ordering for type `B` by extracting a field.
+     * Read as "ordering by this field": `pipe(Ordering.number, Ordering.by(p => p.price))`.
+     *
+     * @example
+     * ```ts
+     * type Product = { name: string; price: number };
+     * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
+     * pipe(products, Arr.sortWith(byPrice));
+     * ```
+     */
+    const by: <A, B>(f: (b: B) => A) => (ord: Ordering<A>) => Ordering<B>;
+}
+
 /**
  * A lazy async computation that always resolves.
  *
@@ -812,4 +977,4 @@ declare namespace Task {
     const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
 }
 
-export { Deferred as D, type Error as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type RetryOptions as d, type TimeoutOptions as e, type WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };
+export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type Error as a, Ordering as b, type WithLog as c, type WithKind as d, type WithError as e, type RetryOptions as f, type TimeoutOptions as g, type WithTimeout as h, type WithMinInterval as i, type WithCooldown as j, type WithConcurrency as k, type WithSize as l, type WithMs as m, type WithN as n, type WithErrors as o, type WithFirst as p, type WithSecond as q };

package/dist/{Task-CnF22Q2o.d.ts → Task-CjYKLeTY.d.ts}

@@ -1,57 +1,5 @@
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
-declare const _deferred: unique symbol;
-/**
- * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
- *
- * Two design choices work together to make the guarantee structural rather than documentary:
- *
- * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
- *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
- * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
- *   no second argument to pass, so chaining and `.catch()` are impossible.
- *
- * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
- * never reject.
- *
- * @example
- * ```ts
- * const value = await Deferred.fromPromise(Promise.resolve(42));
- * // value === 42
- * ```
- */
-type Deferred<A> = {
-    readonly [_deferred]: A;
-    readonly then: (onfulfilled: (value: A) => unknown) => void;
-};
-declare namespace Deferred {
-    /**
-     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
-     * `.catch()`, `.finally()`, and chainable `.then()`.
-     *
-     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
-     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
-     * handle operations that may fail before converting to a `Deferred`.
-     *
-     * @example
-     * ```ts
-     * const d = Deferred.fromPromise(Promise.resolve("hello"));
-     * const value = await d; // "hello"
-     * ```
-     */
-    const fromPromise: <A>(p: Promise<A>) => Deferred<A>;
-    /**
-     * Converts a `Deferred` back into a `Promise`.
-     *
-     * @example
-     * ```ts
-     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
-     * // p is Promise<42>
-     * ```
-     */
-    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
-}
-
 type WithKind<K extends string> = {
     readonly kind: K;
 };
@@ -536,6 +484,223 @@ declare namespace Maybe {
     const ap: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
 }
 
+declare const _deferred: unique symbol;
+/**
+ * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
+ *
+ * Two design choices work together to make the guarantee structural rather than documentary:
+ *
+ * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
+ *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
+ * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
+ *   no second argument to pass, so chaining and `.catch()` are impossible.
+ *
+ * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
+ * never reject.
+ *
+ * @example
+ * ```ts
+ * const value = await Deferred.fromPromise(Promise.resolve(42));
+ * // value === 42
+ * ```
+ */
+type Deferred<A> = {
+    readonly [_deferred]: A;
+    readonly then: (onfulfilled: (value: A) => unknown) => void;
+};
+declare namespace Deferred {
+    /**
+     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
+     * `.catch()`, `.finally()`, and chainable `.then()`.
+     *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.fromPromise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    const fromPromise: <A>(p: Promise<A>) => Deferred<A>;
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
+}
+
+/**
+ * A function that checks whether two values of type `A` are equal.
+ * Use built-in instances (`Equality.string`, `Equality.number`, etc.) as starting points,
+ * then adapt them with `Equality.by` and combine them with `Equality.and`.
+ *
+ * @example
+ * ```ts
+ * type User = { id: string; name: string };
+ * const byId = pipe(Equality.string, Equality.by((u: User) => u.id));
+ *
+ * pipe(users, Arr.uniqWith(byId));
+ * ```
+ */
+type Equality<A> = (a: A, b: A) => boolean;
+declare namespace Equality {
+    /**
+     * Equality for strings. Case-sensitive.
+     *
+     * @example
+     * ```ts
+     * Equality.string("hello", "hello"); // true
+     * Equality.string("hello", "Hello"); // false
+     * ```
+     */
+    const string: Equality<string>;
+    /**
+     * Equality for numbers. Uses strict equality.
+     *
+     * @example
+     * ```ts
+     * Equality.number(42, 42); // true
+     * ```
+     */
+    const number: Equality<number>;
+    /**
+     * Equality for booleans.
+     *
+     * @example
+     * ```ts
+     * Equality.boolean(true, true); // true
+     * ```
+     */
+    const boolean: Equality<boolean>;
+    /**
+     * Equality for `Date` values. Compares by numeric time value.
+     *
+     * @example
+     * ```ts
+     * Equality.date(new Date("2024-01-01"), new Date("2024-01-01")); // true
+     * ```
+     */
+    const date: Equality<Date>;
+    /**
+     * Lifts an element equality into an array equality. Two arrays are equal if they have the
+     * same length and every element pair is equal under `eq`.
+     *
+     * @example
+     * ```ts
+     * Equality.array(Equality.number)([1, 2, 3], [1, 2, 3]); // true
+     * ```
+     */
+    const array: <A>(eq: Equality<A>) => Equality<readonly A[]>;
+    /**
+     * Adapts an equality for type `A` into an equality for type `B` by extracting a field.
+     * Read as "equality by this field": `pipe(Equality.string, Equality.by(u => u.name))`.
+     *
+     * @example
+     * ```ts
+     * type Product = { id: string; price: number };
+     * const byId = pipe(Equality.string, Equality.by((p: Product) => p.id));
+     * byId({ id: "p1", price: 9 }, { id: "p1", price: 12 }); // true
+     * ```
+     */
+    const by: <A, B>(f: (b: B) => A) => (eq: Equality<A>) => Equality<B>;
+    /**
+     * Combines two equalities with logical AND. Both must pass for two values to be considered equal.
+     * Data-last: the first equality is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const exact = pipe(byName, Equality.and(byRole));
+     * exact(userA, userB); // true only if name AND role match
+     * ```
+     */
+    const and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
+}
+
+/**
+ * A function that orders two values of type `A`. Returns a negative number when `a` comes before
+ * `b`, a positive number when `a` comes after `b`, and `0` when they are equal.
+ *
+ * Compatible with `Array.prototype.sort` and `Arr.sortWith`.
+ *
+ * @example
+ * ```ts
+ * type Employee = { name: string; salary: number };
+ *
+ * const byName   = pipe(Ordering.string, Ordering.by((e: Employee) => e.name));
+ * const bySalary = pipe(Ordering.number, Ordering.by((e: Employee) => e.salary));
+ *
+ * pipe(employees, Arr.sortWith(pipe(byName, Ordering.thenBy(bySalary))));
+ * ```
+ */
+type Ordering<A> = (a: A, b: A) => number;
+declare namespace Ordering {
+    /**
+     * Alphabetical ordering for strings.
+     *
+     * @example
+     * ```ts
+     * Ordering.string("apple", "banana"); // negative
+     * ```
+     */
+    const string: Ordering<string>;
+    /**
+     * Numeric ordering. Equivalent to `(a, b) => a - b`.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
+     * ```
+     */
+    const number: Ordering<number>;
+    /**
+     * Ordering for `Date` values by numeric time value.
+     *
+     * @example
+     * ```ts
+     * pipe(dates, Arr.sortWith(Ordering.date)); // earliest first
+     * ```
+     */
+    const date: Ordering<Date>;
+    /**
+     * Flips the direction of an ordering.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortWith(Ordering.reverse(Ordering.number))); // [3, 2, 1]
+     * ```
+     */
+    const reverse: <A>(ord: Ordering<A>) => Ordering<A>;
+    /**
+     * Chains two orderings: the second is used only when the first returns `0`.
+     * Data-last: the first ordering is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const byDeptThenSalary = pipe(byDept, Ordering.thenBy(bySalary));
+     * ```
+     */
+    const thenBy: <A>(ord2: Ordering<A>) => (ord1: Ordering<A>) => Ordering<A>;
+    /**
+     * Adapts an ordering for type `A` into an ordering for type `B` by extracting a field.
+     * Read as "ordering by this field": `pipe(Ordering.number, Ordering.by(p => p.price))`.
+     *
+     * @example
+     * ```ts
+     * type Product = { name: string; price: number };
+     * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
+     * pipe(products, Arr.sortWith(byPrice));
+     * ```
+     */
+    const by: <A, B>(f: (b: B) => A) => (ord: Ordering<A>) => Ordering<B>;
+}
+
 /**
  * A lazy async computation that always resolves.
  *
@@ -812,4 +977,4 @@ declare namespace Task {
     const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
 }
 
-export { Deferred as D, type Error as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type RetryOptions as d, type TimeoutOptions as e, type WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };
+export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type Error as a, Ordering as b, type WithLog as c, type WithKind as d, type WithError as e, type RetryOptions as f, type TimeoutOptions as g, type WithTimeout as h, type WithMinInterval as i, type WithCooldown as j, type WithConcurrency as k, type WithSize as l, type WithMs as m, type WithN as n, type WithErrors as o, type WithFirst as p, type WithSecond as q };

package/dist/{chunk-FWYOEWJ2.mjs → chunk-EHQFUWZW.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-TK5ZCGP2.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
@@ -89,11 +89,25 @@ var Arr;
     }
     return result;
   };
+  Arr2.uniqWith = (eq) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!result.some((x) => eq(x, a))) {
+        result.push(a);
+      }
+    }
+    return result;
+  };
   Arr2.sortBy = (compare) => (data) => {
     const arr = data;
     if (typeof arr.toSorted === "function") return arr.toSorted(compare);
     return [...data].sort(compare);
   };
+  Arr2.sortWith = (ord) => (data) => {
+    const arr = data;
+    if (typeof arr.toSorted === "function") return arr.toSorted(ord);
+    return [...data].sort(ord);
+  };
   Arr2.zip = (other) => (data) => {
     const len = Math.min(data.length, other.length);
     const result = new Array(len);
@@ -126,7 +140,23 @@ var Arr;
     }
     return result;
   };
-  Arr2.flatten = (data) => [].concat(...data);
+  Arr2.flatten = (data) => {
+    let totalLen = 0;
+    const outerLen = data.length;
+    for (let i = 0; i < outerLen; i++) {
+      totalLen += data[i].length;
+    }
+    const result = new Array(totalLen);
+    let idx = 0;
+    for (let i = 0; i < outerLen; i++) {
+      const chunk = data[i];
+      const innerLen = chunk.length;
+      for (let j = 0; j < innerLen; j++) {
+        result[idx++] = chunk[j];
+      }
+    }
+    return result;
+  };
   Arr2.flatMap = (f) => (data) => {
     const n = data.length;
     const result = [];
@@ -365,8 +395,8 @@ var Num;
     }
     return result;
   };
-  Num2.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
-  Num2.between = (min, max) => (n) => n >= min && n <= max;
+  Num2.clamp = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
+  Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
   Num2.parse = (s) => {
     if (s.trim() === "") return Maybe.none();
     const n = Number(s);
@@ -382,6 +412,28 @@ var Num;
   Num2.floor = (n) => Math.floor(n);
   Num2.ceil = (n) => Math.ceil(n);
   Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.none() : Maybe.some(n % divisor);
+  Num2.sum = (ns) => {
+    let result = 0;
+    for (let i = 0; i < ns.length; i++) result += ns[i];
+    return result;
+  };
+  Num2.mean = (ns) => ns.length === 0 ? Maybe.none() : Maybe.some((0, Num2.sum)(ns) / ns.length);
+  Num2.min = (ns) => {
+    if (ns.length === 0) return Maybe.none();
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] < result) result = ns[i];
+    }
+    return Maybe.some(result);
+  };
+  Num2.max = (ns) => {
+    if (ns.length === 0) return Maybe.none();
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] > result) result = ns[i];
+    }
+    return Maybe.some(result);
+  };
 })(Num || (Num = {}));
 
 // src/Utils/Rec.ts
@@ -505,6 +557,7 @@ var Str;
   Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
   Str2.toUpperCase = (s) => s.toUpperCase();
   Str2.toLowerCase = (s) => s.toLowerCase();
+  Str2.capitalize = (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1);
   Str2.lines = (s) => s.split(/\r?\n|\r/);
   Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
   Str2.isEmpty = (s) => s.length === 0;