@nlozgachev/pipelined 0.62.0 → 0.63.0

package/dist/data.d.ts

@@ -1,6 +1,6 @@
-import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-LdhLQx3N.js';
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-DZLizBZ0.js';
-import { B as Brand } from './Duration-B8joKzro.js';
+import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-CCXa8Kvr.js';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-C5RGZUXy.js';
+import { B as Brand } from './Duration-DeyxG6VQ.js';
 import './types.js';
 
 declare namespace ArrTaskResult {
@@ -39,1328 +39,316 @@ declare namespace ArrTaskResult {
      */
     const sequence: <E, A>(data: readonly Task<Result<E, A>>[]) => Task<Result<E, readonly A[]>>;
 }
-declare namespace ArrNonEmpty {
-    /**
-     * Creates a single-element list.
-     *
-     * @example
-     * ```ts
-     * Arr.NonEmpty.singleton(42); // [42]
-     * ```
-     */
-    const singleton: <A>(value: A) => NonEmptyArr<A>;
-    namespace from {
-        /**
-         * Returns Some if the array is non-empty, None otherwise.
-         *
-         * @example
-         * ```ts
-         * Arr.NonEmpty.from.Array([1, 2]); // Some([1, 2])
-         * Arr.NonEmpty.from.Array([]); // None
-         * ```
-         */
-        const Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
-    }
-    /**
-     * Returns the first element of a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * Arr.NonEmpty.head([1, 2, 3]); // 1
-     * ```
-     */
-    const head: <A>(data: NonEmptyArr<A>) => A;
-    /**
-     * Returns the last element of a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * Arr.NonEmpty.last([1, 2, 3]); // 3
-     * ```
-     */
-    const last: <A>(data: NonEmptyArr<A>) => A;
-    /**
-     * Returns all elements except the first.
-     *
-     * @example
-     * ```ts
-     * Arr.NonEmpty.tail([1, 2, 3]); // [2, 3]
-     * ```
-     */
-    const tail: <A>(data: NonEmptyArr<A>) => readonly A[];
-    /**
-     * Reduces a NonEmptyArr from the left without an initial value.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4] as Arr.NonEmpty<number>, Arr.NonEmpty.reduce((a: number, b: number) => a + b)); // 10
-     * ```
-     */
-    const reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyArr<A>) => A;
-    /**
-     * Transforms each element of a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.map(n => n * 2)); // [2]
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
-    /**
-     * Transforms each element of a NonEmptyArr, also receiving the index.
-     *
-     * @example
-     * ```ts
-     * pipe(Arr.NonEmpty.singleton("a"), Arr.NonEmpty.mapWithIndex((i, s) => `${i}:${s}`)); // ["0:a"]
-     * ```
-     */
-    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
-    /**
-     * Inserts a separator between every element of a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2] as Arr.NonEmpty<number>, Arr.NonEmpty.intersperse(0)); // [1, 0, 2]
-     * ```
-     */
-    const intersperse: <A>(sep: A) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
-    /**
-     * Concatenates a NonEmptyArr with a standard array.
-     *
-     * @example
-     * ```ts
-     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.concat([2, 3])); // [1, 2, 3]
-     * ```
-     */
-    const concat: <A>(other: readonly A[]) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
-    /**
-     * Reverses a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.reverse); // [1]
-     * ```
-     */
-    const reverse: <A>(data: NonEmptyArr<A>) => NonEmptyArr<A>;
-}
-/**
- * Functional array utilities that compose well with pipe.
- * All functions are data-last and curried where applicable.
- * Safe access functions return Maybe instead of throwing or returning undefined.
- *
- * @example
- * ```ts
- * pipe(
- *   [1, 2, 3, 4, 5],
- *   Arr.filter(n => n > 2),
- *   Arr.map(n => n * 10),
- *   Arr.head
- * ); // Some(30)
- * ```
- */
-declare namespace Arr {
-    /**
-     * A type alias representing an array that is guaranteed to contain at least one element.
-     * Under the hood, this is a read-only tuple structure: `readonly [A, ...A[]]`.
-     *
-     * @example
-     * ```ts
-     * const list: Arr.NonEmpty<number> = [1, 2, 3];
-     * ```
-     */
-    export type NonEmpty<A> = NonEmptyArr<A>;
-    /**
-     * Returns the first element of an array, or None if the array is empty.
-     *
-     * @example
-     * ```ts
-     * Arr.head([1, 2, 3]); // Some(1)
-     * Arr.head([]); // None
-     * ```
-     */
-    export const head: <A>(data: readonly A[]) => Maybe<A>;
-    /**
-     * Returns the last element of an array, or None if the array is empty.
-     *
-     * @example
-     * ```ts
-     * Arr.last([1, 2, 3]); // Some(3)
-     * Arr.last([]); // None
-     * ```
-     */
-    export const last: <A>(data: readonly A[]) => Maybe<A>;
-    /**
-     * Returns all elements except the first, or None if the array is empty.
-     *
-     * @example
-     * ```ts
-     * Arr.tail([1, 2, 3]); // Some([2, 3])
-     * Arr.tail([]); // None
-     * ```
-     */
-    export const tail: <A>(data: readonly A[]) => Maybe<readonly A[]>;
-    /**
-     * Returns all elements except the last, or None if the array is empty.
-     *
-     * @example
-     * ```ts
-     * Arr.init([1, 2, 3]); // Some([1, 2])
-     * Arr.init([]); // None
-     * ```
-     */
-    export const init: <A>(data: readonly A[]) => Maybe<readonly A[]>;
-    /**
-     * Returns the first element matching the predicate, or None.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)
-     * ```
-     */
-    export const findFirst: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
-    /**
-     * Returns the last element matching the predicate, or None.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)
-     * ```
-     */
-    export const findLast: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
-    /**
-     * Returns the index of the first element matching the predicate, or None.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.findIndex(n => n > 2)); // Some(2)
-     * ```
-     */
-    export const findIndex: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<number>;
-    /**
-     * Transforms each element of an array.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
-     * ```
-     */
-    export const map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
-    /**
-     * Transforms each element using both its value and its zero-based index.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   ["a", "b", "c"],
-     *   Arr.mapWithIndex((i, s) => ({ position: i + 1, value: s }))
-     * ); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]
-     * ```
-     */
-    export const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
-    /**
-     * Filters elements that satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]
-     * ```
-     */
-    export const filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
-    /**
-     * Maps each element to a Maybe and collects only the Some values.
-     * Combines map and filter in a single pass.
-     *
-     * @example
-     * ```ts
-     * const parseNum = (s: string): Maybe<number> => {
-     *   const n = Number(s);
-     *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-     * };
-     *
-     * pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]
-     * ```
-     */
-    export const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
-    /**
-     * Splits an array into two groups based on a predicate.
-     * First group contains elements that satisfy the predicate,
-     * second group contains the rest.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]
-     * ```
-     */
-    export const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
-    /**
-     * Narrows a list of Maybe values down to a list of their underlying values,
-     * discarding all None instances.
-     *
-     * @example
-     * ```ts
-     * Arr.compact([Maybe.make.some(1), Maybe.make.none(), Maybe.make.some(3)]); // [1, 3]
-     * ```
-     */
-    export const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
-    /**
-     * Separates an array of Result values into two separate lists of errors and successes.
-     * Returns a tuple containing `[errors, successes]`.
-     *
-     * @example
-     * ```ts
-     * Arr.separate([Result.make.ok(1), Result.make.err("bad"), Result.make.ok(3)]); // [["bad"], [1, 3]]
-     * ```
-     */
-    export const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
-    /**
-     * Maps each element to a Result, and separates the results into a tuple of failures and successes.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [1, 2, 3, 4],
-     *   Arr.partitionMap(n => n % 2 === 0 ? Result.make.ok(n) : Result.make.err(`odd: ${n}`))
-     * ); // [["odd: 1", "odd: 3"], [2, 4]]
-     * ```
-     */
-    export const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
-    /**
-     * Groups elements by a key function.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   ["apple", "avocado", "banana"],
-     *   Arr.groupBy(s => s[0])
-     * ); // { a: ["apple", "avocado"], b: ["banana"] }
-     * ```
-     */
-    export const groupBy: <A>(f: (a: A) => string) => (data: readonly A[]) => Record<string, NonEmptyArr<A>>;
-    /**
-     * Removes duplicate elements using strict equality.
-     *
-     * @example
-     * ```ts
-     * Arr.uniq([1, 2, 2, 3, 1]); // [1, 2, 3]
-     * ```
-     */
-    export const uniq: <A>(data: readonly A[]) => readonly A[];
-    /**
-     * Removes duplicate elements by comparing the result of a key function.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [{id: 1, name: "a"}, {id: 1, name: "b"}, {id: 2, name: "c"}],
-     *   Arr.uniqBy(x => x.id)
-     * ); // [{id: 1, name: "a"}, {id: 2, name: "c"}]
-     * ```
-     */
-    export const uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
-    /**
-     * Removes duplicate elements using a custom equality check.
-     * Preserves the order of first occurrences. Complements `uniq` (reference equality)
-     * and `uniqBy` (key extraction).
-     *
-     * @example
-     * ```ts
-     * type Point = { x: number; y: number };
-     * const eqPoint: Equality<Point> = (a, b) => a.x === b.x && a.y === b.y;
-     *
-     * pipe(
-     *   [{ x: 1, y: 1 }, { x: 2, y: 2 }, { x: 1, y: 1 }],
-     *   Arr.uniqWith(eqPoint),
-     * ); // [{ x: 1, y: 1 }, { x: 2, y: 2 }]
-     * ```
-     */
-    export const uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
-    /**
-     * Sorts an array using a comparison function. Returns a new array.
-     * To sort with a typed `Ordering<A>`, prefer `Arr.sortWith`.
-     *
-     * @example
-     * ```ts
-     * pipe([3, 1, 2], Arr.sortBy((a, b) => a - b)); // [1, 2, 3]
-     * ```
-     */
-    export const sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
-    /**
-     * Sorts an array using an `Ordering<A>`. Returns a new array without mutating the original.
-     * Use this over `sortBy` when you have a typed `Ordering<A>` from the `Ordering` module.
-     *
-     * @example
-     * ```ts
-     * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
-     *
-     * type Product = { price: number };
-     * const products: Product[] = [{ price: 20 }, { price: 10 }];
-     * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
-     * pipe(products, Arr.sortWith(byPrice));
-     * ```
-     */
-    export const sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
-    /**
-     * Pairs up elements from two arrays. Stops at the shorter array.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.zip(["a", "b"])); // [[1, "a"], [2, "b"]]
-     * ```
-     */
-    export const zip: <B>(other: readonly B[]) => <A>(data: readonly A[]) => readonly (readonly [A, B])[];
-    /**
-     * Combines elements from two arrays using a function. Stops at the shorter array.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2], Arr.zipWith((a: number, b: string) => `${a}${b}`)(["a", "b"])); // ["1a", "2b"]
-     * ```
-     */
-    export const zipWith: <A, B, C>(f: (a: A, b: B) => C) => (other: readonly B[]) => (data: readonly A[]) => readonly C[];
-    /**
-     * Inserts a separator between every element.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]
-     * ```
-     */
-    export const intersperse: <A>(sep: A) => (data: readonly A[]) => readonly A[];
-    /**
-     * Concatenates a standard array with another array.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2], Arr.concat([3, 4])); // [1, 2, 3, 4]
-     * ```
-     */
-    export const concat: <A>(other: readonly A[]) => (data: readonly A[]) => readonly A[];
-    /**
-     * Splits an array into chunks of the given size.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4, 5], Arr.chunksOf(2)); // [[1, 2], [3, 4], [5]]
-     * ```
-     */
-    export const chunksOf: (n: number) => <A>(data: readonly A[]) => readonly (readonly A[])[];
-    /**
-     * Flattens a nested array by one level.
-     *
-     * @example
-     * ```ts
-     * Arr.flatten([[1, 2], [3], [4, 5]]); // [1, 2, 3, 4, 5]
-     * ```
-     */
-    export const flatten: <A>(data: readonly (readonly A[])[]) => readonly A[];
-    /**
-     * Maps each element to an array and flattens the result.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]
-     * ```
-     */
-    export const flatMap: <A, B>(f: (a: A) => readonly B[]) => (data: readonly A[]) => readonly B[];
-    /**
-     * Reduces an array from the left.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.reduce(0, (acc, n) => acc + n)); // 6
-     * ```
-     */
-    export const reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
-    interface TaskTraverse {
-        <A, B>(f: (a: A) => Task<B>): (data: readonly A[]) => Task<readonly B[]>;
-        Result: typeof ArrTaskResult.traverse;
-    }
-    interface TaskSequence {
-        <A>(data: readonly Task<A>[]): Task<readonly A[]>;
-        Result: typeof ArrTaskResult.sequence;
-    }
-    export namespace traverse {
-        const Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<readonly B[]>;
-        const Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => Result<E, readonly B[]>;
-        const Task: TaskTraverse;
-    }
-    export namespace sequence {
-        const Maybe: <A>(data: readonly Maybe<A>[]) => Maybe<readonly A[]>;
-        const Result: <E, A>(data: readonly Result<E, A>[]) => Result<E, readonly A[]>;
-        const Task: TaskSequence;
-    }
-    export namespace is {
-        /**
-         * Returns true if the array is empty.
-         *
-         * @example
-         * ```ts
-         * Arr.is.empty([]);  // true
-         * Arr.is.empty([1]); // false
-         * ```
-         */
-        const empty: <A>(data: readonly A[]) => data is readonly [];
-        /**
-         * Returns true if the array is non-empty (type guard).
-         *
-         * @example
-         * ```ts
-         * Arr.is.nonEmpty([1, 2]); // true
-         * Arr.is.nonEmpty([]);     // false
-         * ```
-         */
-        const nonEmpty: <A>(data: readonly A[]) => data is NonEmpty<A>;
-    }
-    /**
-     * Prepends a value to the beginning of an array, returning a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2], Arr.prepend(0)); // [0, 1, 2]
-     * ```
-     */
-    export const prepend: <A>(value: A) => (data: readonly A[]) => NonEmpty<A>;
-    /**
-     * Appends a value to the end of an array, returning a NonEmptyArr.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2], Arr.append(3)); // [1, 2, 3]
-     * ```
-     */
-    export const append: <A>(value: A) => (data: readonly A[]) => NonEmpty<A>;
-    /**
-     * Returns the length of an array.
-     *
-     * @example
-     * ```ts
-     * Arr.size([1, 2, 3]); // 3
-     * ```
-     */
-    export const size: <A>(data: readonly A[]) => number;
-    /**
-     * Returns true if any element satisfies the predicate.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.some(n => n > 2)); // true
-     * ```
-     */
-    export const some: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
-    /**
-     * Returns true if all elements satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
-     * ```
-     */
-    export const every: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
-    /**
-     * Reverses an array. Returns a new array.
-     *
-     * @example
-     * ```ts
-     * Arr.reverse([1, 2, 3]); // [3, 2, 1]
-     * ```
-     */
-    export const reverse: <A>(data: readonly A[]) => readonly A[];
-    /**
-     * Returns a new array with `item` inserted before the element at `index`.
-     * Negative indices are clamped to 0; indices beyond the array length append to the end.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.insertAt(1, 99)); // [1, 99, 2, 3]
-     * pipe([1, 2, 3], Arr.insertAt(0, 99)); // [99, 1, 2, 3]
-     * pipe([1, 2, 3], Arr.insertAt(3, 99)); // [1, 2, 3, 99]
-     * ```
-     */
-    export const insertAt: <A>(index: number, item: A) => (data: readonly A[]) => readonly A[];
-    /**
-     * Returns a new array with the element at `index` removed.
-     * Returns the original array unchanged if `index` is out of bounds.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.removeAt(1)); // [1, 3]
-     * pipe([1, 2, 3], Arr.removeAt(0)); // [2, 3]
-     * pipe([1, 2, 3], Arr.removeAt(5)); // [1, 2, 3]
-     * ```
-     */
-    export const removeAt: (index: number) => <A>(data: readonly A[]) => readonly A[];
-    /**
-     * Takes the first n elements from an array.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.take(2)); // [1, 2]
-     * ```
-     */
-    export const take: (n: number) => <A>(data: readonly A[]) => readonly A[];
-    /**
-     * Drops the first n elements from an array.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.drop(2)); // [3, 4]
-     * ```
-     */
-    export const drop: (n: number) => <A>(data: readonly A[]) => readonly A[];
-    /**
-     * Takes elements from the start while the predicate holds.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 1], Arr.takeWhile(n => n < 3)); // [1, 2]
-     * ```
-     */
-    export const takeWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
-    /**
-     * Drops elements from the start while the predicate holds.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 1], Arr.dropWhile(n => n < 3)); // [3, 1]
-     * ```
-     */
-    export const dropWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
-    /**
-     * Like `reduce`, but returns every intermediate accumulator as an array.
-     * The initial value is not included — the output has the same length as the input.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]
-     * ```
-     */
-    export const scan: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => readonly B[];
-    /**
-     * Splits an array at an index into a `[before, after]` tuple.
-     * Negative indices clamp to 0; indices beyond the array length clamp to the end.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.splitAt(2)); // [[1, 2], [3, 4]]
-     * pipe([1, 2, 3], Arr.splitAt(0));    // [[], [1, 2, 3]]
-     * pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]
-     * ```
-     */
-    export const splitAt: (index: number) => <A>(data: readonly A[]) => readonly [readonly A[], readonly A[]];
-    /**
-     * Partitions an array by applying a function returning `Maybe<B>`.
-     * Elements returning `None` are gathered into `failures` (original `A` values);
-     * elements returning `Some(b)` are gathered into `successes` (`B` values).
-     *
-     * @example
-     * ```ts
-     * const parseNumber = (s: string) => isNaN(Number(s)) ? Maybe.make.none() : Maybe.make.some(Number(s));
-     * pipe(["1", "abc", "3"], Arr.partitionMaybe(parseNumber)); // [["abc"], [1, 3]]
-     * ```
-     */
-    export const partitionMaybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly [failures: readonly A[], successes: readonly B[]];
-    /**
-     * Safely looks up an element by index. Supports negative indices counting back from the end.
-     * Returns `None` if the index is out of bounds.
-     *
-     * @example
-     * ```ts
-     * pipe([10, 20, 30], Arr.at(1));  // Some(20)
-     * pipe([10, 20, 30], Arr.at(-1)); // Some(30)
-     * pipe([10, 20, 30], Arr.at(5));  // None
-     * ```
-     */
-    export const at: (index: number) => <A>(data: readonly A[]) => Maybe<A>;
-    /**
-     * Finds the first element in an array for which `f` returns `Some(b)`.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   ["1", "a", "2"],
-     *   Arr.findMap((s) => isNaN(Number(s)) ? Maybe.make.none() : Maybe.make.some(Number(s)))
-     * ); // Some(1)
-     * ```
-     */
-    export const findMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<B>;
-    /**
-     * Indexes elements of an array into a `ReadonlyMap<K, A>` using a key extraction function.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }],
-     *   Arr.indexBy((u) => u.id)
-     * ); // ReadonlyMap { 1 => { id: 1, name: "Alice" }, 2 => { id: 2, name: "Bob" } }
-     * ```
-     */
-    export const indexBy: <A, K>(keyFn: (a: A) => K) => (data: readonly A[]) => ReadonlyMap<K, A>;
-    /**
-     * Counts occurrences of each element in an array, returning a `ReadonlyMap<A, number>`.
-     *
-     * @example
-     * ```ts
-     * Arr.frequencies(["a", "b", "a", "c", "b", "a"]);
-     * // ReadonlyMap { "a" => 3, "b" => 2, "c" => 1 }
-     * ```
-     */
-    export const frequencies: <A>(data: readonly A[]) => ReadonlyMap<A, number>;
-    /**
-     * Groups consecutive elements that share the same key returned by `keyFn`.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [1, 1, 2, 3, 3, 1],
-     *   Arr.chunkBy((n) => n)
-     * ); // [[1, 1], [2], [3, 3], [1]]
-     * ```
-     */
-    export const chunkBy: <A, K>(keyFn: (a: A) => K) => (data: readonly A[]) => readonly (readonly A[])[];
-    /**
-     * Removes consecutive duplicate elements.
-     * An optional `Equality<A>` can be provided (defaults to `Object.is`).
-     *
-     * @example
-     * ```ts
-     * Arr.dedupeAdjacent()([1, 1, 2, 2, 1, 3]); // [1, 2, 1, 3]
-     * ```
-     */
-    export const dedupeAdjacent: <A>(eq?: Equality<A>) => (data: readonly A[]) => readonly A[];
-    /**
-     * Produces a sliding window of `size` elements over an array, advancing by `step` (default `1`).
-     * Returns an empty array if `size <= 0` or `size > data.length`.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.windowed(2)); // [[1, 2], [2, 3], [3, 4]]
-     * pipe([1, 2, 3, 4], Arr.windowed(2, { step: 2 })); // [[1, 2], [3, 4]]
-     * ```
-     */
-    export const windowed: (size: number, options?: {
-        step?: number;
-    }) => <A>(data: readonly A[]) => readonly (readonly A[])[];
-    /**
-     * Generates an array from an initial seed state until `f` returns `None`.
-     *
-     * @example
-     * ```ts
-     * Arr.unfold(1, (n) => n > 3 ? Maybe.make.none() : Maybe.make.some([n, n + 1]));
-     * // [1, 2, 3]
-     * ```
-     */
-    export const unfold: <A, S>(initial: S, f: (state: S) => Maybe<readonly [A, S]>) => readonly A[];
-    export const NonEmpty: typeof ArrNonEmpty;
-    export {  };
-}
-
-/**
- * Safe conversion and arithmetic utilities for arbitrary-precision integers (`bigint`).
- * All functions are pure and data-last to compose cleanly with `pipe`.
- *
- * @example
- * ```ts
- * import { BigNum } from "@nlozgachev/pipelined/data";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const result = pipe(
- *   BigNum.from.string("100"),
- *   Maybe.map(BigNum.add(50n))
- * ); // Some(150n)
- * ```
- */
-declare namespace BigNum {
-    namespace from {
-        /**
-         * Safely parses a string into a `bigint`. Returns `None` if parsing fails.
-         *
-         * @example
-         * ```ts
-         * BigNum.from.string("123"); // Some(123n)
-         * BigNum.from.string("abc"); // None
-         * ```
-         */
-        const string: (s: string) => Maybe<bigint>;
-        /**
-         * Safely converts a number into a `bigint`. Returns `None` for floats, `NaN`, or non-safe integers.
-         *
-         * @example
-         * ```ts
-         * BigNum.from.number(42);   // Some(42n)
-         * BigNum.from.number(3.14); // None
-         * ```
-         */
-        const number: (n: number) => Maybe<bigint>;
-    }
-    namespace to {
-        /**
-         * Safely converts a `bigint` to a `number`. Returns `None` if the value is outside JavaScript's safe integer range.
-         *
-         * @example
-         * ```ts
-         * BigNum.to.number(42n);                    // Some(42)
-         * BigNum.to.number(9007199254740993n);      // None
-         * ```
-         */
-        const number: (b: bigint) => Maybe<number>;
-    }
-    /**
-     * Adds `b` to `a`. Data-last curried signature: `add(b)(a)` = `a + b`.
-     *
-     * @example
-     * ```ts
-     * pipe(10n, BigNum.add(5n)); // 15n
-     * ```
-     */
-    const add: (b: bigint) => (a: bigint) => bigint;
-    /**
-     * Subtracts `b` from `a`. Data-last curried signature: `sub(b)(a)` = `a - b`.
-     *
-     * @example
-     * ```ts
-     * pipe(10n, BigNum.sub(3n)); // 7n
-     * ```
-     */
-    const sub: (b: bigint) => (a: bigint) => bigint;
-    /**
-     * Multiplies `a` by `b`. Data-last curried signature: `mul(b)(a)` = `a * b`.
-     *
-     * @example
-     * ```ts
-     * pipe(6n, BigNum.mul(7n)); // 42n
-     * ```
-     */
-    const mul: (b: bigint) => (a: bigint) => bigint;
-    /**
-     * Divides `a` by `b`. Returns `None` if `b` is `0n`.
-     *
-     * @example
-     * ```ts
-     * pipe(20n, BigNum.div(4n)); // Some(5n)
-     * pipe(5n, BigNum.div(0n));  // None
-     * ```
-     */
-    const div: (b: bigint) => (a: bigint) => Maybe<bigint>;
-    /**
-     * Computes remainder of `a / b`. Returns `None` if `b` is `0n`.
-     *
-     * @example
-     * ```ts
-     * pipe(10n, BigNum.mod(3n)); // Some(1n)
-     * pipe(5n, BigNum.mod(0n));  // None
-     * ```
-     */
-    const mod: (b: bigint) => (a: bigint) => Maybe<bigint>;
-    /**
-     * Clamps `a` between `min` and `max` (inclusive).
-     *
-     * @example
-     * ```ts
-     * pipe(150n, BigNum.clamp(0n, 100n)); // 100n
-     * ```
-     */
-    const clamp: (min: bigint, max: bigint) => (a: bigint) => bigint;
-    /**
-     * Returns `true` if `a` is in the range `[start, end)` (inclusive start, exclusive end).
-     *
-     * @example
-     * ```ts
-     * pipe(5n, BigNum.inRange(1n, 10n)); // true
-     * ```
-     */
-    const inRange: (start: bigint, end: bigint) => (a: bigint) => boolean;
-    /**
-     * Returns absolute value of a `bigint`.
-     *
-     * @example
-     * ```ts
-     * BigNum.abs(-42n); // 42n
-     * ```
-     */
-    const abs: (a: bigint) => bigint;
-    /**
-     * Returns the minimum of `a` and `b`.
-     *
-     * @example
-     * ```ts
-     * pipe(10n, BigNum.min(5n)); // 5n
-     * ```
-     */
-    const min: (b: bigint) => (a: bigint) => bigint;
-    /**
-     * Returns the maximum of `a` and `b`.
-     *
-     * @example
-     * ```ts
-     * pipe(10n, BigNum.max(5n)); // 10n
-     * ```
-     */
-    const max: (b: bigint) => (a: bigint) => bigint;
+interface TaskTraverse {
+    <A, B>(f: (a: A) => Task<B>): (data: readonly A[]) => Task<readonly B[]>;
+    Result: typeof ArrTaskResult.traverse;
+}
+interface TaskSequence {
+    <A>(data: readonly Task<A>[]): Task<readonly A[]>;
+    Result: typeof ArrTaskResult.sequence;
+}
+declare const Arr: {
+    head: <A>(data: readonly A[]) => Maybe<A>;
+    last: <A>(data: readonly A[]) => Maybe<A>;
+    tail: <A>(data: readonly A[]) => Maybe<readonly A[]>;
+    init: <A>(data: readonly A[]) => Maybe<readonly A[]>;
+    findFirst: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
+    findLast: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
+    findIndex: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<number>;
+    map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
+    mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
+    filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
+    partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
+    separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+    partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
+    groupBy: <A>(f: (a: A) => string) => (data: readonly A[]) => Record<string, NonEmptyArr<A>>;
+    uniq: <A>(data: readonly A[]) => readonly A[];
+    uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
+    uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
+    sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
+    sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
+    zip: <B>(other: readonly B[]) => <A>(data: readonly A[]) => readonly (readonly [A, B])[];
+    zipWith: <A, B, C>(f: (a: A, b: B) => C) => (other: readonly B[]) => (data: readonly A[]) => readonly C[];
+    intersperse: <A>(sep: A) => (data: readonly A[]) => readonly A[];
+    concat: <A>(other: readonly A[]) => (data: readonly A[]) => readonly A[];
+    chunksOf: (n: number) => <A>(data: readonly A[]) => readonly (readonly A[])[];
+    flatten: <A>(data: readonly (readonly A[])[]) => readonly A[];
+    flatMap: <A, B>(f: (a: A) => readonly B[]) => (data: readonly A[]) => readonly B[];
+    reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
+    prepend: <A>(value: A) => (data: readonly A[]) => NonEmptyArr<A>;
+    append: <A>(value: A) => (data: readonly A[]) => NonEmptyArr<A>;
+    size: <A>(data: readonly A[]) => number;
+    some: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
+    every: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
+    reverse: <A>(data: readonly A[]) => readonly A[];
+    insertAt: <A>(index: number, item: A) => (data: readonly A[]) => readonly A[];
+    removeAt: (index: number) => <A>(data: readonly A[]) => readonly A[];
+    take: (n: number) => <A>(data: readonly A[]) => readonly A[];
+    drop: (n: number) => <A>(data: readonly A[]) => readonly A[];
+    takeWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    dropWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    scan: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => readonly B[];
+    splitAt: (index: number) => <A>(data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    partitionMaybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly [failures: readonly A[], successes: readonly B[]];
+    at: (index: number) => <A>(data: readonly A[]) => Maybe<A>;
+    findMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<B>;
+    indexBy: <A, K>(keyFn: (a: A) => K) => (data: readonly A[]) => ReadonlyMap<K, A>;
+    frequencies: <A>(data: readonly A[]) => ReadonlyMap<A, number>;
+    chunkBy: <A, K>(keyFn: (a: A) => K) => (data: readonly A[]) => readonly (readonly A[])[];
+    dedupeAdjacent: <A>(eq?: Equality<A>) => (data: readonly A[]) => readonly A[];
+    windowed: (windowSize: number, options?: {
+        step?: number;
+    }) => <A>(data: readonly A[]) => readonly (readonly A[])[];
+    unfold: <A, S>(initial: S, f: (state: S) => Maybe<readonly [A, S]>) => readonly A[];
+    from: {
+        Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+    };
+    is: {
+        empty: <A>(data: readonly A[]) => data is readonly [];
+        nonEmpty: <A>(data: readonly A[]) => data is NonEmptyArr<A>;
+    };
+    traverse: {
+        Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<readonly B[]>;
+        Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => Result<E, readonly B[]>;
+        Task: TaskTraverse;
+    };
+    sequence: {
+        Maybe: <A>(data: readonly Maybe<A>[]) => Maybe<readonly A[]>;
+        Result: <E, A>(data: readonly Result<E, A>[]) => Result<E, readonly A[]>;
+        Task: TaskSequence;
+    };
+    NonEmpty: {
+        singleton: <A>(value: A) => NonEmptyArr<A>;
+        from: {
+            Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+        };
+        head: <A>(data: NonEmptyArr<A>) => A;
+        last: <A>(data: NonEmptyArr<A>) => A;
+        tail: <A>(data: NonEmptyArr<A>) => readonly A[];
+        reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyArr<A>) => A;
+        map: <A, B>(f: (a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
+        mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
+        intersperse: <A>(sep: A) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
+        concat: <A>(other: readonly A[]) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
+        reverse: <A>(data: NonEmptyArr<A>) => NonEmptyArr<A>;
+    };
+};
+declare namespace Arr {
+    type NonEmpty<A> = NonEmptyArr<A>;
 }
 
 /**
- * A branded type representing a key-value dictionary with at least one entry.
- */
-type NonEmptyMap<K, V> = Brand<NonEmpty<"Dict">, ReadonlyMap<K, V>>;
-/**
- * Functional utilities for key-value dictionaries (`ReadonlyMap<K, V>`). All functions are pure
- * and data-last — they compose naturally with `pipe`.
- *
- * Unlike plain objects (`Rec`), dictionaries support any key type, preserve insertion order, and
- * make membership checks explicit via `lookup` returning `Maybe`.
+ * Safe conversion and arithmetic utilities for arbitrary-precision integers (`bigint`).
+ * All functions are pure and data-last to compose cleanly with `pipe`.
  *
  * @example
  * ```ts
- * import { Dict } from "@nlozgachev/pipelined/data";
+ * import { BigNum } from "@nlozgachev/pipelined/data";
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
- * const scores = pipe(
- *   Dict.from.entries([["alice", 10], ["bob", 8], ["carol", 10]] as const),
- *   Dict.filter(n => n >= 10),
- *   Dict.map(n => `${n} points`),
- * );
- * // ReadonlyMap { "alice" => "10 points", "carol" => "10 points" }
+ * const result = pipe(
+ *   BigNum.from.string("100"),
+ *   Maybe.map(BigNum.add(50n))
+ * ); // Some(150n)
  * ```
  */
-declare namespace DictNonEmpty {
-    /**
-     * Creates a NonEmptyMap containing a single key-value entry.
-     *
-     * @example
-     * ```ts
-     * Dict.NonEmpty.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
-     * ```
-     */
-    const singleton: <K, V>(key: K, value: V) => NonEmptyMap<K, V>;
-    namespace from {
-        /**
-         * Returns Some containing NonEmptyMap if the map is not empty, None otherwise.
-         *
-         * @example
-         * ```ts
-         * Dict.NonEmpty.from.Map(Dict.from.entries([["a", 1]])); // Some(ReadonlyMap { "a" => 1 })
-         * Dict.NonEmpty.from.Map(Dict.empty());                 // None
-         * ```
-         */
-        const Map: <K, V>(m: ReadonlyMap<K, V>) => Maybe<NonEmptyMap<K, V>>;
-    }
-    /**
-     * Returns a non-empty array of keys, in insertion order.
-     *
-     * @example
-     * ```ts
-     * Dict.NonEmpty.keys(Dict.NonEmpty.singleton("a", 1)); // ["a"]
-     * ```
-     */
-    const keys: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<K>;
-    /**
-     * Returns a non-empty array of values, in insertion order.
-     *
-     * @example
-     * ```ts
-     * Dict.NonEmpty.values(Dict.NonEmpty.singleton("a", 1)); // [1]
-     * ```
-     */
-    const values: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<V>;
-    /**
-     * Returns a non-empty array of entry tuples, in insertion order.
-     *
-     * @example
-     * ```ts
-     * Dict.NonEmpty.entries(Dict.NonEmpty.singleton("a", 1)); // [["a", 1]]
-     * ```
-     */
-    const entries: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<readonly [K, V]>;
-    /**
-     * Reduces a NonEmptyMap's values from the left without an initial seed value.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.reduce((a, b) => a + b)); // 1
-     * ```
-     */
-    const reduce: <V>(f: (acc: V, value: V) => V) => <K>(m: NonEmptyMap<K, V>) => V;
-    /**
-     * Transforms each value in the non-empty dictionary.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.map(n => n * 2));
-     * // ReadonlyMap { "a" => 2 }
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => <K>(m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
-    /**
-     * Transforms each value in the non-empty dictionary, also receiving the key.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.mapWithKey((k, v) => `${k}:${v}`));
-     * // ReadonlyMap { "a" => "a:1" }
-     * ```
-     */
-    const mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
-}
-declare namespace Dict {
-    /**
-     * A branded type representing a key-value dictionary with at least one entry.
-     */
-    type NonEmpty<K, V> = NonEmptyMap<K, V>;
-    namespace is {
-        /**
-         * Returns `true` if the dictionary has no entries.
-         *
-         * @example
-         * ```ts
-         * Dict.is.empty(Dict.empty()); // true
-         * ```
-         */
-        const empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
+declare const BigNum: {
+    from: {
         /**
-         * Type guard to check if a dictionary is non-empty.
+         * Safely parses a string into a `bigint`. Returns `None` if parsing fails.
          *
          * @example
          * ```ts
-         * Dict.is.nonEmpty(Dict.from.entries([["a", 1]])); // true
-         * Dict.is.nonEmpty(Dict.empty());                 // false
+         * BigNum.from.string("123"); // Some(123n)
+         * BigNum.from.string("abc"); // None
          * ```
          */
-        const nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmpty<K, V>;
-    }
-    /**
-     * Creates an empty dictionary.
-     *
-     * @example
-     * ```ts
-     * Dict.empty<string, number>(); // ReadonlyMap {}
-     * ```
-     */
-    const empty: <K, V>() => ReadonlyMap<K, V>;
-    /**
-     * Creates a dictionary with a single entry.
-     *
-     * @example
-     * ```ts
-     * Dict.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
-     * ```
-     */
-    const singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
-    namespace from {
+        string: (s: string) => Maybe<bigint>;
         /**
-         * Creates a dictionary from an array of key-value pairs.
+         * Safely converts a number into a `bigint`. Returns `None` for floats, `NaN`, or non-safe integers.
          *
          * @example
          * ```ts
-         * Dict.from.entries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }
+         * BigNum.from.number(42);   // Some(42n)
+         * BigNum.from.number(3.14); // None
          * ```
          */
-        const entries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+        number: (n: number) => Maybe<bigint>;
+    };
+    to: {
         /**
-         * Creates a dictionary from a plain object. Keys are always strings.
+         * Safely converts a `bigint` to a `number`. Returns `None` if the value is outside JavaScript's safe integer range.
          *
          * @example
          * ```ts
-         * Dict.from.Record({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }
+         * BigNum.to.number(42n);                    // Some(42)
+         * BigNum.to.number(9007199254740993n);      // None
          * ```
          */
-        const Record: <V>(rec: Readonly<Record<string, V>>) => ReadonlyMap<string, V>;
-    }
-    /**
-     * Groups elements of an array into a dictionary keyed by the result of `keyFn`. Each key maps
-     * to the array of elements that produced it, in insertion order. Uses the native `Map.groupBy`
-     * when available, falling back to a manual loop in older environments.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [{ name: "alice", role: "admin" }, { name: "bob", role: "viewer" }, { name: "carol", role: "admin" }],
-     *   Dict.groupBy(user => user.role),
-     * );
-     * // ReadonlyMap { "admin" => [alice, carol], "viewer" => [bob] }
-     * ```
-     */
-    const groupBy: <K, A>(keyFn: (a: A) => K) => (items: readonly A[]) => ReadonlyMap<K, readonly A[]>;
-    /**
-     * Returns `true` if the dictionary contains the given key.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.from.entries([["a", 1]]), Dict.has("a")); // true
-     * pipe(Dict.from.entries([["a", 1]]), Dict.has("b")); // false
-     * ```
-     */
-    const has: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => boolean;
-    /**
-     * Looks up a value by key, returning `Some(value)` if found and `None` if not.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.from.entries([["a", 1]]), Dict.lookup("a")); // Some(1)
-     * pipe(Dict.from.entries([["a", 1]]), Dict.lookup("b")); // None
-     * ```
-     */
-    const lookup: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => Maybe<V>;
-    /**
-     * Returns the number of entries in the dictionary.
-     *
-     * @example
-     * ```ts
-     * Dict.size(Dict.from.entries([["a", 1], ["b", 2]])); // 2
-     * ```
-     */
-    const size: <K, V>(m: ReadonlyMap<K, V>) => number;
-    /**
-     * Returns all keys as a readonly array, in insertion order.
-     *
-     * @example
-     * ```ts
-     * Dict.keys(Dict.from.entries([["a", 1], ["b", 2]])); // ["a", "b"]
-     * ```
-     */
-    const keys: <K, V>(m: ReadonlyMap<K, V>) => readonly K[];
-    /**
-     * Returns all values as a readonly array, in insertion order.
-     *
-     * @example
-     * ```ts
-     * Dict.values(Dict.from.entries([["a", 1], ["b", 2]])); // [1, 2]
-     * ```
-     */
-    const values: <K, V>(m: ReadonlyMap<K, V>) => readonly V[];
-    /**
-     * Returns all key-value pairs as a readonly array of tuples, in insertion order.
-     *
-     * @example
-     * ```ts
-     * Dict.entries(Dict.from.entries([["a", 1], ["b", 2]])); // [["a", 1], ["b", 2]]
-     * ```
-     */
-    const entries: <K, V>(m: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
-    /**
-     * Returns a new dictionary with the given key set to the given value.
-     * If the key already exists, its value is replaced.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.from.entries([["a", 1]]), Dict.insert("b", 2));
-     * // ReadonlyMap { "a" => 1, "b" => 2 }
-     * ```
-     */
-    const insert: <K, V>(key: K, value: V) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-    /**
-     * Returns a new dictionary with the given key removed.
-     * If the key does not exist, the dictionary is returned unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.from.entries([["a", 1], ["b", 2]]), Dict.remove("a"));
-     * // ReadonlyMap { "b" => 2 }
-     * ```
-     */
-    const remove: <K, V>(key: K) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-    /**
-     * Returns a new dictionary with the value at `key` set by `f`. If the key does not exist,
-     * `f` receives `None`. If the key exists, `f` receives `Some(currentValue)`.
-     *
-     * Useful for incrementing counters, initialising defaults, or conditional updates.
-     *
-     * @example
-     * ```ts
-     * const increment = (opt: Maybe<number>) => pipe(opt, Maybe.getOrElse(() => 0)) + 1;
-     * pipe(Dict.from.entries([["views", 5]]), Dict.upsert("views", increment)); // { views: 6 }
-     * pipe(Dict.from.entries([["views", 5]]), Dict.upsert("likes", increment)); // { views: 5, likes: 1 }
-     * ```
-     */
-    const upsert: <K, V>(key: K, f: (existing: Maybe<V>) => V) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-    /**
-     * Transforms each value in the dictionary.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.from.entries([["a", 1], ["b", 2]]), Dict.map(n => n * 2));
-     * // ReadonlyMap { "a" => 2, "b" => 4 }
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
-    /**
-     * Transforms each value in the dictionary, also receiving the key.
-     *
-     * @example
-     * ```ts
-     * pipe(Dict.from.entries([["a", 1], ["b", 2]]), Dict.mapWithKey((k, v) => `${k}:${v}`));
-     * // ReadonlyMap { "a" => "a:1", "b" => "b:2" }
-     * ```
-     */
-    const mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+        number: (b: bigint) => Maybe<number>;
+    };
     /**
-     * Returns a new dictionary containing only the entries for which the predicate returns `true`.
+     * Adds `b` to `a`. Data-last curried signature: `add(b)(a)` = `a + b`.
      *
      * @example
      * ```ts
-     * pipe(Dict.from.entries([["a", 1], ["b", 3], ["c", 0]]), Dict.filter(n => n > 0));
-     * // ReadonlyMap { "a" => 1, "b" => 3 }
+     * pipe(10n, BigNum.add(5n)); // 15n
      * ```
      */
-    const filter: <A>(predicate: (a: A) => boolean) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+    add: (b: bigint) => (a: bigint) => bigint;
     /**
-     * Returns a new dictionary containing only the entries for which the predicate returns `true`.
-     * The predicate also receives the key.
+     * Subtracts `b` from `a`. Data-last curried signature: `sub(b)(a)` = `a - b`.
      *
      * @example
      * ```ts
-     * pipe(Dict.from.entries([["a", 1], ["b", 2]]), Dict.filterWithKey((k, v) => k !== "a" && v > 0));
-     * // ReadonlyMap { "b" => 2 }
+     * pipe(10n, BigNum.sub(3n)); // 7n
      * ```
      */
-    const filterWithKey: <K, A>(predicate: (key: K, a: A) => boolean) => (m: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+    sub: (b: bigint) => (a: bigint) => bigint;
     /**
-     * Removes all `None` values from a `ReadonlyMap<K, Maybe<A>>`, returning a plain
-     * `ReadonlyMap<K, A>`. Useful when building dictionaries from fallible lookups.
+     * Multiplies `a` by `b`. Data-last curried signature: `mul(b)(a)` = `a * b`.
      *
      * @example
      * ```ts
-     * Dict.compact(Dict.from.entries<string, Maybe<number>>([
-     *   ["a", Maybe.make.some(1)],
-     *   ["b", Maybe.make.none()],
-     *   ["c", Maybe.make.some(3)],
-     * ]));
-     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * pipe(6n, BigNum.mul(7n)); // 42n
      * ```
      */
-    const compact: <K, A>(m: ReadonlyMap<K, Maybe<A>>) => ReadonlyMap<K, A>;
+    mul: (b: bigint) => (a: bigint) => bigint;
     /**
-     * Applies `f` to each value. Entries where `f` returns `None` are removed; entries where
-     * `f` returns `Some` are kept with the unwrapped value. Combines map and filter in one pass.
+     * Divides `a` by `b`. Returns `None` if `b` is `0n`.
      *
      * @example
      * ```ts
-     * const parse = (s: string): Maybe<number> => {
-     *     const n = Number(s);
-     *     return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-     * };
-     * Dict.filterMap(parse)(Dict.from.Record({ a: "1", b: "two", c: "3" }));
-     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * pipe(20n, BigNum.div(4n)); // Some(5n)
+     * pipe(5n, BigNum.div(0n));  // None
      * ```
      */
-    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+    div: (b: bigint) => (a: bigint) => Maybe<bigint>;
     /**
-     * Merges two dictionaries. When both contain the same key, the value from `other` takes
-     * precedence.
+     * Computes remainder of `a / b`. Returns `None` if `b` is `0n`.
      *
      * @example
      * ```ts
-     * pipe(
-     *   Dict.from.entries([["a", 1], ["b", 2]]),
-     *   Dict.union(Dict.from.entries([["b", 3], ["c", 4]])),
-     * );
-     * // ReadonlyMap { "a" => 1, "b" => 3, "c" => 4 }
+     * pipe(10n, BigNum.mod(3n)); // Some(1n)
+     * pipe(5n, BigNum.mod(0n));  // None
      * ```
      */
-    const union: <K, V>(other: ReadonlyMap<K, V>) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    mod: (b: bigint) => (a: bigint) => Maybe<bigint>;
     /**
-     * Returns a new dictionary containing only the entries whose keys appear in both dictionaries.
-     * Values are taken from the left (base) dictionary.
+     * Clamps `a` between `min` and `max` (inclusive).
      *
      * @example
      * ```ts
-     * pipe(
-     *   Dict.from.entries([["a", 1], ["b", 2], ["c", 3]]),
-     *   Dict.intersection(Dict.from.entries([["b", 99], ["c", 0]])),
-     * );
-     * // ReadonlyMap { "b" => 2, "c" => 3 }
+     * pipe(150n, BigNum.clamp(0n, 100n)); // 100n
      * ```
      */
-    const intersection: <K, V>(other: ReadonlyMap<K, unknown>) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    clamp: (min: bigint, max: bigint) => (a: bigint) => bigint;
     /**
-     * Returns a new dictionary containing only the entries whose keys do not appear in `other`.
+     * Returns `true` if `a` is in the range `[start, end)` (inclusive start, exclusive end).
      *
      * @example
      * ```ts
-     * pipe(
-     *   Dict.from.entries([["a", 1], ["b", 2], ["c", 3]]),
-     *   Dict.difference(Dict.from.entries([["b", 0]])),
-     * );
-     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * pipe(5n, BigNum.inRange(1n, 10n)); // true
      * ```
      */
-    const difference: <K, V>(other: ReadonlyMap<K, unknown>) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    inRange: (start: bigint, end: bigint) => (a: bigint) => boolean;
     /**
-     * Folds the dictionary into a single value by applying `f` to each value in insertion order.
-     * When you also need the key, use `reduceWithKey`.
+     * Returns absolute value of a `bigint`.
      *
      * @example
      * ```ts
-     * Dict.reduce(0, (acc, value: number) => acc + value)(
-     *   Dict.from.entries([["a", 1], ["b", 2], ["c", 3]])
-     * ); // 6
+     * BigNum.abs(-42n); // 42n
      * ```
      */
-    const reduce: <A, B>(init: B, f: (acc: B, value: A) => B) => <K>(m: ReadonlyMap<K, A>) => B;
+    abs: (a: bigint) => bigint;
     /**
-     * Folds the dictionary into a single value by applying `f` to each key-value pair in insertion
-     * order.
+     * Returns the minimum of `a` and `b`.
      *
      * @example
      * ```ts
-     * Dict.reduceWithKey("", (acc, value, key) => acc + key + ":" + value + " ")(
-     *   Dict.from.entries([["a", 1], ["b", 2]])
-     * ); // "a:1 b:2 "
+     * pipe(10n, BigNum.min(5n)); // 5n
      * ```
      */
-    const reduceWithKey: <K, A, B>(init: B, f: (acc: B, value: A, key: K) => B) => (m: ReadonlyMap<K, A>) => B;
+    min: (b: bigint) => (a: bigint) => bigint;
     /**
-     * Merges two maps using a custom combination function on key collisions.
-     * Supports both uncurried `Dict.mergeWith(combine)(first, second)` and curried `pipe(first, Dict.mergeWith(combine)(second))`.
+     * Returns the maximum of `a` and `b`.
      *
      * @example
      * ```ts
-     * const combineStats = Dict.mergeWith((a: number, b: number) => a + b);
-     * const map1 = Dict.from.entries([["a", 1], ["b", 2]]);
-     * const map2 = Dict.from.entries([["b", 3], ["c", 4]]);
-     * combineStats(map1, map2);
-     * pipe(map1, combineStats(map2));
+     * pipe(10n, BigNum.max(5n)); // 10n
      * ```
      */
-    function mergeWith<K, V>(combine: (a: V, b: V) => V): {
-        (second: ReadonlyMap<K, V>): (first: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-        (first: ReadonlyMap<K, V>, second: ReadonlyMap<K, V>): ReadonlyMap<K, V>;
+    max: (b: bigint) => (a: bigint) => bigint;
+};
+
+/**
+ * A branded type representing a key-value dictionary with at least one entry.
+ */
+type NonEmptyMap<K, V> = Brand<NonEmpty<"Dict">, ReadonlyMap<K, V>>;
+declare function mergeWith$1<V>(combine: (a: V, b: V) => V): {
+    <K>(first: ReadonlyMap<K, V>, second: ReadonlyMap<K, V>): ReadonlyMap<K, V>;
+    <K>(second: ReadonlyMap<K, V>): (first: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+};
+declare const Dict: {
+    is: {
+        empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
+        nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmptyMap<K, V>;
     };
-    namespace to {
-        /**
-         * Converts a `ReadonlyMap<string, V>` to a plain object. Only meaningful when keys are strings.
-         *
-         * @example
-         * ```ts
-         * Dict.to.Record(Dict.from.entries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }
-         * ```
-         */
-        const Record: <V>(m: ReadonlyMap<string, V>) => Readonly<Record<string, V>>;
-    }
-    /**
-     * Transforms key and value pairs simultaneously into a new ReadonlyMap.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Dict.from.entries([["a", 1], ["b", 2]]),
-     *   Dict.mapEntries((k, v) => [k.toUpperCase(), v * 10])
-     * ); // Map { "A" => 10, "B" => 20 }
-     * ```
-     */
-    const mapEntries: <K1, V1, K2, V2>(f: (key: K1, value: V1) => readonly [K2, V2]) => (data: ReadonlyMap<K1, V1>) => ReadonlyMap<K2, V2>;
-    /**
-     * Transforms keys of a ReadonlyMap while preserving values.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Dict.from.entries([["a", 1], ["b", 2]]),
-     *   Dict.mapKeys((k) => k.toUpperCase())
-     * ); // Map { "A" => 1, "B" => 2 }
-     * ```
+    empty: <K, V>() => ReadonlyMap<K, V>;
+    singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
+    from: {
+        entries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+        Record: <K extends string, V>(record: Readonly<Record<K, V>>) => ReadonlyMap<K, V>;
+        Array: <K, V>(data: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+        nullable: <K, V>(data: ReadonlyMap<K, V> | null | undefined) => Maybe<ReadonlyMap<K, V>>;
+    };
+    to: {
+        Record: <K extends string, V>(map: ReadonlyMap<K, V>) => Readonly<Record<K, V>>;
+    };
+    groupBy: <A, K>(f: (a: A) => K) => (as: readonly A[]) => ReadonlyMap<K, NonEmptyArr<A>>;
+    has: <K, V>(key: K) => (data: ReadonlyMap<K, V>) => boolean;
+    lookup: <K, V>(key: K) => (data: ReadonlyMap<K, V>) => Maybe<V>;
+    size: <K, V>(data: ReadonlyMap<K, V>) => number;
+    keys: <K, V>(data: ReadonlyMap<K, V>) => readonly K[];
+    values: <K, V>(data: ReadonlyMap<K, V>) => readonly V[];
+    entries: <K, V>(data: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
+    insert: <K, V>(key: K, value: V) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    remove: <K, V>(key: K) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    upsert: <K, V>(key: K, f: (existing: Maybe<V>) => V) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    map: <A, B>(f: (a: A) => B) => <K>(data: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+    mapWithKey: <K, A, B>(f: (key: K, value: A) => B) => (data: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+    filter: <A>(predicate: (a: A) => boolean) => <K>(data: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+    filterWithKey: <K, A>(predicate: (key: K, value: A) => boolean) => (data: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+    compact: <K, A>(data: ReadonlyMap<K, Maybe<A>>) => ReadonlyMap<K, A>;
+    filterMap: <A, B>(f: (a: A) => Maybe<B>) => <K>(data: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+    union: <K, V>(other: ReadonlyMap<K, V>) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    intersection: <K, V>(other: ReadonlyMap<K, V>) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    difference: <K, V>(other: ReadonlyMap<K, V>) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    reduce: <B, V>(init: B, f: (acc: B, value: V) => B) => <K>(data: ReadonlyMap<K, V>) => B;
+    reduceWithKey: <B, K, V>(init: B, f: (acc: B, value: V, key: K) => B) => (data: ReadonlyMap<K, V>) => B;
+    mergeWith: typeof mergeWith$1;
+    mapEntries: <K1, V1, K2, V2>(f: (key: K1, value: V1) => readonly [K2, V2]) => (data: ReadonlyMap<K1, V1>) => ReadonlyMap<K2, V2>;
+    mapKeys: <K1, K2, V>(f: (key: K1) => K2) => (data: ReadonlyMap<K1, V>) => ReadonlyMap<K2, V>;
+    NonEmpty: {
+        singleton: <K, V>(key: K, value: V) => NonEmptyMap<K, V>;
+        from: {
+            Map: <K, V>(m: ReadonlyMap<K, V>) => Maybe<NonEmptyMap<K, V>>;
+        };
+        keys: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<K>;
+        values: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<V>;
+        entries: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<readonly [K, V]>;
+        reduce: <V>(f: (acc: V, value: V) => V) => <K>(m: NonEmptyMap<K, V>) => V;
+        map: <A, B>(f: (a: A) => B) => <K>(m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+        mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+    };
+};
+declare namespace Dict {
+    /**
+     * A branded type representing a key-value dictionary with at least one entry.
      */
-    const mapKeys: <K1, K2, V>(f: (key: K1) => K2) => (data: ReadonlyMap<K1, V>) => ReadonlyMap<K2, V>;
-    const NonEmpty: typeof DictNonEmpty;
+    type NonEmpty<K, V> = NonEmptyMap<K, V>;
 }
 
 /**
@@ -1378,7 +366,7 @@ declare namespace Dict {
  * ); // Ok("Alice")
  * ```
  */
-declare namespace Json {
+declare const Json: {
     /**
      * Safely parses a JSON string into `unknown`.
      * Converts thrown exceptions into a `Result<SyntaxError, unknown>`.
@@ -1389,7 +377,7 @@ declare namespace Json {
      * Json.parse('{invalid}'); // Err(SyntaxError)
      * ```
      */
-    const parse: (text: string) => Result<SyntaxError, unknown>;
+    parse: (text: string) => Result<SyntaxError, unknown>;
     /**
      * Safely stringifies a value into a JSON string.
      * Converts thrown exceptions (e.g. circular references) into a `Result<TypeError, string>`.
@@ -1399,27 +387,11 @@ declare namespace Json {
      * Json.stringify({ a: 1 }); // Ok('{"a":1}')
      * ```
      */
-    const stringify: (value: unknown, replacer?: (this: any, key: string, value: any) => any, space?: string | number) => Result<TypeError, string>;
-}
+    stringify: (value: unknown, replacer?: (this: any, key: string, value: any) => any, space?: string | number) => Result<TypeError, string>;
+};
 
-/**
- * Number utilities for common operations. All transformation functions are data-last
- * and curried so they compose naturally with `pipe` and `Arr.map`.
- *
- * @example
- * ```ts
- * import { Num } from "@nlozgachev/pipelined/data";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * pipe(
- *   Num.range(1, 6),
- *   Arr.map(Num.multiply(2)),
- *   Arr.filter(Num.between(4, 8))
- * ); // [4, 6, 8]
- * ```
- */
-declare namespace Num {
-    namespace is {
+declare const Num: {
+    is: {
         /**
          * Returns `true` when the number is equal to zero.
          *
@@ -1429,7 +401,7 @@ declare namespace Num {
          * Num.is.zero(5); // false
          * ```
          */
-        const zero: (n: number) => boolean;
+        zero: (n: number) => boolean;
         /**
          * Returns `true` when the number is a whole integer.
          *
@@ -1439,7 +411,7 @@ declare namespace Num {
          * Num.is.integer(3.14); // false
          * ```
          */
-        const integer: (n: number) => boolean;
+        integer: (n: number) => boolean;
         /**
          * Returns `true` when the number is a finite float (fractional number).
          *
@@ -1449,7 +421,7 @@ declare namespace Num {
          * Num.is.float(5);    // false
          * ```
          */
-        const float: (n: number) => boolean;
+        float: (n: number) => boolean;
         /**
          * Returns `true` when the number is finite (not `Infinity`, `-Infinity`, or `NaN`).
          *
@@ -1459,7 +431,7 @@ declare namespace Num {
          * Num.is.finite(Infinity); // false
          * ```
          */
-        const finite: (n: number) => boolean;
+        finite: (n: number) => boolean;
         /**
          * Returns `true` when the value is `NaN`.
          *
@@ -1469,7 +441,7 @@ declare namespace Num {
          * Num.is.nan(42);  // false
          * ```
          */
-        const nan: (n: number) => boolean;
+        nan: (n: number) => boolean;
         /**
          * Returns `true` when the number is an even integer.
          *
@@ -1480,7 +452,7 @@ declare namespace Num {
          * Num.is.even(2.5); // false
          * ```
          */
-        const even: (n: number) => boolean;
+        even: (n: number) => boolean;
         /**
          * Returns `true` when the number is an odd integer.
          *
@@ -1491,7 +463,7 @@ declare namespace Num {
          * Num.is.odd(2.5); // false
          * ```
          */
-        const odd: (n: number) => boolean;
+        odd: (n: number) => boolean;
         /**
          * Returns `true` when the number is strictly greater than zero.
          *
@@ -1502,7 +474,7 @@ declare namespace Num {
          * Num.is.positive(-5); // false
          * ```
          */
-        const positive: (n: number) => boolean;
+        positive: (n: number) => boolean;
         /**
          * Returns `true` when the number is strictly less than zero.
          *
@@ -1513,8 +485,8 @@ declare namespace Num {
          * Num.is.negative(5);  // false
          * ```
          */
-        const negative: (n: number) => boolean;
-    }
+        negative: (n: number) => boolean;
+    };
     /**
      * Generates an array of numbers from `from` to `to` (both inclusive),
      * stepping by `step` (default `1`). If `step` is negative or zero, or `from > to`,
@@ -1530,7 +502,7 @@ declare namespace Num {
      * Num.range(3, 3);       // [3]
      * ```
      */
-    const range: (from: number, to: number, step?: number) => readonly number[];
+    range: (from: number, to: number, step?: number) => readonly number[];
     /**
      * Clamps a number between `min` and `max` (both inclusive).
      *
@@ -1541,7 +513,7 @@ declare namespace Num {
      * pipe(42, Num.clamp(0, 100));  // 42
      * ```
      */
-    const clamp: (min: number, max: number) => (n: number) => number;
+    clamp: (min: number, max: number) => (n: number) => number;
     /**
      * Returns `true` when the number is between `min` and `max` (both inclusive).
      *
@@ -1552,7 +524,7 @@ declare namespace Num {
      * pipe(10, Num.between(1, 10)); // true
      * ```
      */
-    const between: (min: number, max: number) => (n: number) => boolean;
+    between: (min: number, max: number) => (n: number) => boolean;
     /**
      * Returns `true` when the number is in the range `[start, end)` (inclusive of `start`, exclusive of `end`).
      *
@@ -1563,7 +535,7 @@ declare namespace Num {
      * pipe(10, Num.inRange(1, 10)); // false
      * ```
      */
-    const inRange: (start: number, end: number) => (n: number) => boolean;
+    inRange: (start: number, end: number) => (n: number) => boolean;
     /**
      * Parses a string as a number. Returns `None` when the result is `NaN`.
      *
@@ -1575,7 +547,7 @@ declare namespace Num {
      * Num.parse("");     // None
      * ```
      */
-    const parse: (s: string) => Maybe<number>;
+    parse: (s: string) => Maybe<number>;
     /**
      * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
      *
@@ -1585,533 +557,260 @@ declare namespace Num {
      * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
      * ```
      */
-    const add: (b: number) => (a: number) => number;
+    add: (b: number) => (a: number) => number;
     /**
      * Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
      *
      * @example
      * ```ts
      * pipe(10, Num.subtract(3));                  // 7
-     * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
-     * ```
-     */
-    const subtract: (b: number) => (a: number) => number;
-    /**
-     * Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
-     *
-     * @example
-     * ```ts
-     * pipe(6, Num.multiply(7));                    // 42
-     * pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
-     * ```
-     */
-    const multiply: (b: number) => (a: number) => number;
-    /**
-     * Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
-     *
-     * @example
-     * ```ts
-     * pipe(20, Num.divide(4));                           // Some(5)
-     * pipe(5, Num.divide(0));                            // None
-     * pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]
-     * ```
-     */
-    const divide: (b: number) => (a: number) => Maybe<number>;
-    /**
-     * Returns the absolute value of a number.
-     *
-     * @example
-     * ```ts
-     * pipe(-5, Num.abs); // 5
-     * pipe(5, Num.abs);  // 5
-     * ```
-     */
-    const abs: (n: number) => number;
-    /**
-     * Negates a number (arithmetic negation).
-     *
-     * @example
-     * ```ts
-     * pipe(5, Num.negate);  // -5
-     * pipe(-5, Num.negate); // 5
-     * ```
-     */
-    const negate: (n: number) => number;
-    /**
-     * Rounds a number to the nearest integer.
-     *
-     * @example
-     * ```ts
-     * pipe(3.5, Num.round); // 4
-     * pipe(3.4, Num.round); // 3
-     * ```
-     */
-    const round: (n: number) => number;
-    /**
-     * Rounds a number down to the nearest integer.
-     *
-     * @example
-     * ```ts
-     * pipe(3.9, Num.floor); // 3
-     * pipe(-3.2, Num.floor); // -4
-     * ```
-     */
-    const floor: (n: number) => number;
-    /**
-     * Rounds a number up to the nearest integer.
-     *
-     * @example
-     * ```ts
-     * pipe(3.1, Num.ceil); // 4
-     * pipe(-3.9, Num.ceil); // -3
-     * ```
-     */
-    const ceil: (n: number) => number;
-    /**
-     * Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
-     * Data-last: `remainder(divisor)(a)` = `a % divisor`.
-     *
-     * @example
-     * ```ts
-     * pipe(10, Num.remainder(3));                           // Some(1)
-     * pipe(5, Num.remainder(0));                            // None
-     * pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]
-     * ```
-     */
-    const remainder: (divisor: number) => (n: number) => Maybe<number>;
-    /**
-     * Computes the sum of a list of numbers. Returns `0` if the list is empty.
-     *
-     * @example
-     * ```ts
-     * Num.sum([1, 2, 3]); // 6
-     * Num.sum([]);        // 0
-     * ```
-     */
-    const sum: (ns: readonly number[]) => number;
-    /**
-     * Computes the mean of a list of numbers. Returns `None` if the list is empty.
-     *
-     * @example
-     * ```ts
-     * Num.mean([1, 2, 3]); // Some(2)
-     * Num.mean([]);        // None
-     * ```
-     */
-    const mean: (ns: readonly number[]) => Maybe<number>;
-    /**
-     * Computes the minimum of a list of numbers. Returns `None` if the list is empty.
-     *
-     * @example
-     * ```ts
-     * Num.min([5, 1, 3]); // Some(1)
-     * Num.min([]);        // None
-     * ```
-     */
-    const min: (ns: readonly number[]) => Maybe<number>;
-    /**
-     * Computes the maximum of a list of numbers. Returns `None` if the list is empty.
-     *
-     * @example
-     * ```ts
-     * Num.max([1, 5, 3]); // Some(5)
-     * Num.max([]);        // None
-     * ```
-     */
-    const max: (ns: readonly number[]) => Maybe<number>;
-    /**
-     * Formats a number using `Intl.NumberFormat`. Returns `None` when `n` is `NaN` or non-finite.
-     * Data-last curried signature.
-     *
-     * @example
-     * ```ts
-     * const formatCurrency = Num.format({ style: "currency", currency: "USD" }, "en-US");
-     * pipe(1234.5, formatCurrency); // Some("$1,234.50")
-     * pipe(NaN, formatCurrency);    // None
-     * ```
-     */
-    const format: (options?: Intl.NumberFormatOptions, locales?: string | string[]) => (n: number) => Maybe<string>;
-}
-
-/**
- * A branded type representing a record with at least one key-value pair.
- */
-type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">, Readonly<Record<K, A>>>;
-declare namespace RecNonEmpty {
-    /**
-     * Creates a NonEmpty record from a single key-value pair.
-     *
-     * @example
-     * ```ts
-     * Rec.NonEmpty.singleton("a", 1); // { a: 1 }
-     * ```
-     */
-    const singleton: <K extends string, A>(key: K, value: A) => NonEmptyRecord<A, K>;
-    namespace from {
-        /**
-         * Creates a NonEmpty record from a standard record if it is not empty.
-         *
-         * @example
-         * ```ts
-         * Rec.NonEmpty.from.Record({ a: 1 }); // Some({ a: 1 })
-         * Rec.NonEmpty.from.Record({});      // None
-         * ```
-         */
-        const Record: <K extends string, A>(data: Readonly<Record<K, A>>) => Maybe<NonEmptyRecord<A, K>>;
-    }
-    /**
-     * Returns a non-empty array of keys for a NonEmpty record.
-     *
-     * @example
-     * ```ts
-     * Rec.NonEmpty.keys(Rec.NonEmpty.singleton("a", 1)); // ["a"]
-     * ```
-     */
-    const keys: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<K>;
-    /**
-     * Returns a non-empty array of values for a NonEmpty record.
-     *
-     * @example
-     * ```ts
-     * Rec.NonEmpty.values(Rec.NonEmpty.singleton("a", 1)); // [1]
-     * ```
-     */
-    const values: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<A>;
-    /**
-     * Returns a non-empty array of entry tuples for a NonEmpty record.
-     *
-     * @example
-     * ```ts
-     * Rec.NonEmpty.entries(Rec.NonEmpty.singleton("a", 1)); // [["a", 1]]
-     * ```
-     */
-    const entries: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<readonly [K, A]>;
-    /**
-     * Reduces a NonEmpty record's values from the left without an initial value.
-     *
-     * @example
-     * ```ts
-     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.reduce((a, b) => a + b)); // 1
-     * ```
-     */
-    const reduce: <A>(f: (acc: A, a: A) => A) => <K extends string>(data: NonEmptyRecord<A, K>) => A;
-    /**
-     * Transforms each value of a NonEmpty record.
-     *
-     * @example
-     * ```ts
-     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.map(n => n * 2)); // { a: 2 }
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
-    /**
-     * Transforms each value of a NonEmpty record, also receiving the key.
-     *
-     * @example
-     * ```ts
-     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.mapWithKey((k, v) => `${k}:${v}`)); // { a: "a:1" }
-     * ```
-     */
-    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
-}
-/**
- * Functional record/object utilities that compose well with pipe.
- * All functions are data-last and curried where applicable.
- *
- * @example
- * ```ts
- * pipe(
- *   { a: 1, b: 2, c: 3 },
- *   Rec.filter(n => n > 1),
- *   Rec.map(n => n * 10)
- * ); // { b: 20, c: 30 }
- * ```
- */
-declare namespace Rec {
-    /**
-     * A branded type representing a record with at least one key-value pair.
-     */
-    type NonEmpty<A, K extends string = string> = NonEmptyRecord<A, K>;
-    namespace is {
-        /**
-         * Returns true if the record has no keys.
-         *
-         * @example
-         * ```ts
-         * Rec.is.empty({});       // true
-         * Rec.is.empty({ a: 1 }); // false
-         * ```
-         */
-        const empty: <A>(data: Readonly<Record<string, A>>) => boolean;
-        /**
-         * Type guard to check if a record is non-empty.
-         *
-         * @example
-         * ```ts
-         * Rec.is.nonEmpty({ a: 1 }); // true
-         * Rec.is.nonEmpty({});       // false
-         * ```
-         */
-        const nonEmpty: <A, K extends string>(data: Readonly<Record<K, A>>) => data is NonEmptyRecord<A, K>;
-    }
-    /**
-     * Transforms each value in a record.
-     *
-     * @example
-     * ```ts
-     * pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
-    /**
-     * Maps each value in a record with a function returning a `Maybe`, keeping only `Some` values.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   { a: 1, b: 2, c: 3 },
-     *   Rec.filterMap((n) => (n % 2 === 0 ? Maybe.make.some(n * 10) : Maybe.make.none()))
-     * ); // { b: 20 }
-     * ```
-     */
-    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
-    /**
-     * Transforms each value in a record, also receiving the key.
-     *
-     * @example
-     * ```ts
-     * pipe({ a: 1, b: 2 }, Rec.mapWithKey((k, v) => `${k}:${v}`));
-     * // { a: "a:1", b: "b:2" }
-     * ```
-     */
-    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
-    /**
-     * Filters values in a record by a predicate.
-     *
-     * @example
-     * ```ts
-     * pipe({ a: 1, b: 2, c: 3 }, Rec.filter(n => n > 1)); // { b: 2, c: 3 }
-     * ```
-     */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-    /**
-     * Filters values in a record by a predicate that also receives the key.
-     *
-     * @example
-     * ```ts
-     * pipe({ a: 1, b: 2, c: 3 }, Rec.filterWithKey((k, v) => k !== "a" && v > 0));
-     * // { b: 2 }
-     * ```
-     */
-    const filterWithKey: <A>(predicate: (key: string, a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-    /**
-     * Looks up a value by key, returning Maybe.
-     *
-     * @example
-     * ```ts
-     * pipe({ a: 1, b: 2 }, Rec.lookup("a")); // Some(1)
-     * pipe({ a: 1, b: 2 }, Rec.lookup("c")); // None
+     * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
      * ```
      */
-    const lookup: <K extends string>(key: K) => <V>(data: Record<string, V>) => Maybe<V>;
+    subtract: (b: number) => (a: number) => number;
     /**
-     * Returns all keys of a record.
+     * Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
      *
      * @example
      * ```ts
-     * Rec.keys({ a: 1, b: 2 }); // ["a", "b"]
+     * pipe(6, Num.multiply(7));                    // 42
+     * pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
      * ```
      */
-    const keys: <T extends Record<string, unknown>>(data: T) => readonly (keyof T & string)[];
+    multiply: (b: number) => (a: number) => number;
     /**
-     * Returns all values of a record.
+     * Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
      *
      * @example
      * ```ts
-     * Rec.values({ a: 1, b: 2 }); // [1, 2]
+     * pipe(20, Num.divide(4));                           // Some(5)
+     * pipe(5, Num.divide(0));                            // None
+     * pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]
      * ```
      */
-    const values: <T extends Record<string, unknown>>(data: T) => readonly T[keyof T & string][];
+    divide: (b: number) => (a: number) => Maybe<number>;
     /**
-     * Returns all key-value pairs of a record.
+     * Returns the absolute value of a number.
      *
      * @example
      * ```ts
-     * Rec.entries({ a: 1, b: 2 }); // [["a", 1], ["b", 2]]
+     * pipe(-5, Num.abs); // 5
+     * pipe(5, Num.abs);  // 5
      * ```
      */
-    const entries: <T extends Record<string, unknown>>(data: T) => readonly (readonly [keyof T, T[keyof T]])[];
-    namespace from {
-        /**
-         * Creates a record from key-value pairs.
-         *
-         * @example
-         * ```ts
-         * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
-         * ```
-         */
-        const entries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
-    }
+    abs: (n: number) => number;
     /**
-     * Groups elements of an array into a record keyed by the result of `keyFn`. Each key maps to
-     * the array of elements that produced it, in insertion order.
-     *
-     * Unlike `Dict.groupBy`, keys are always strings. Use `Dict.groupBy` when you need non-string
-     * keys or want to avoid the plain-object prototype chain.
+     * Negates a number (arithmetic negation).
      *
      * @example
      * ```ts
-     * pipe(
-     *   ["apple", "avocado", "banana", "blueberry"],
-     *   Rec.groupBy(s => s[0]),
-     * ); // { a: ["apple", "avocado"], b: ["banana", "blueberry"] }
+     * pipe(5, Num.negate);  // -5
+     * pipe(-5, Num.negate); // 5
      * ```
      */
-    const groupBy: <A>(keyFn: (a: A) => string) => (items: readonly A[]) => Readonly<Record<string, readonly A[]>>;
+    negate: (n: number) => number;
     /**
-     * Picks specific keys from a record.
+     * Rounds a number to the nearest integer.
      *
      * @example
      * ```ts
-     * pipe({ a: 1, b: 2, c: 3 }, Rec.pick("a", "c")); // { a: 1, c: 3 }
+     * pipe(3.5, Num.round); // 4
+     * pipe(3.4, Num.round); // 3
      * ```
      */
-    const pick: <K extends string>(...pickedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Pick<A, K>;
+    round: (n: number) => number;
     /**
-     * Omits specific keys from a record.
+     * Rounds a number down to the nearest integer.
      *
      * @example
      * ```ts
-     * pipe({ a: 1, b: 2, c: 3 }, Rec.omit("b")); // { a: 1, c: 3 }
+     * pipe(3.9, Num.floor); // 3
+     * pipe(-3.2, Num.floor); // -4
      * ```
      */
-    const omit: <K extends string>(...omittedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Omit<A, K>;
+    floor: (n: number) => number;
     /**
-     * Merges two records. Values from the second record take precedence.
+     * Rounds a number up to the nearest integer.
      *
      * @example
      * ```ts
-     * pipe({ a: 1, b: 2 }, Rec.merge({ b: 3, c: 4 })); // { a: 1, b: 3, c: 4 }
+     * pipe(3.1, Num.ceil); // 4
+     * pipe(-3.9, Num.ceil); // -3
      * ```
      */
-    const merge: <A>(other: Readonly<Record<string, A>>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    ceil: (n: number) => number;
     /**
-     * Merges two records using a custom combination function on key collisions.
-     * Supports both uncurried `Rec.mergeWith(combine)(first, second)` and curried `pipe(first, Rec.mergeWith(combine)(second))`.
+     * Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
+     * Data-last: `remainder(divisor)(a)` = `a % divisor`.
      *
      * @example
      * ```ts
-     * const combineStats = Rec.mergeWith((a: number, b: number) => a + b);
-     * combineStats({ a: 1, b: 2 }, { b: 3, c: 4 }); // { a: 1, b: 5, c: 4 }
-     * pipe({ a: 1, b: 2 }, combineStats({ b: 3, c: 4 })); // { a: 1, b: 5, c: 4 }
+     * pipe(10, Num.remainder(3));                           // Some(1)
+     * pipe(5, Num.remainder(0));                            // None
+     * pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]
      * ```
      */
-    function mergeWith<A>(combine: (a: A, b: A) => A): {
-        (second: Readonly<Record<string, A>>): (first: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-        (first: Readonly<Record<string, A>>, second: Readonly<Record<string, A>>): Readonly<Record<string, A>>;
-    };
+    remainder: (divisor: number) => (n: number) => Maybe<number>;
     /**
-     * Returns the number of keys in a record.
+     * Computes the sum of a list of numbers. Returns `0` if the list is empty.
      *
      * @example
      * ```ts
-     * Rec.size({ a: 1, b: 2 }); // 2
+     * Num.sum([1, 2, 3]); // 6
+     * Num.sum([]);        // 0
      * ```
      */
-    const size: <A>(data: Readonly<Record<string, A>>) => number;
+    sum: (ns: readonly number[]) => number;
     /**
-     * Transforms each key while preserving values.
-     * If two keys map to the same new key, the last one wins.
+     * Computes the mean of a list of numbers. Returns `None` if the list is empty.
      *
      * @example
      * ```ts
-     * pipe({ firstName: "Alice", lastName: "Smith" }, Rec.mapKeys(k => k.toUpperCase()));
-     * // { FIRSTNAME: "Alice", LASTNAME: "Smith" }
+     * Num.mean([1, 2, 3]); // Some(2)
+     * Num.mean([]);        // None
      * ```
      */
-    const mapKeys: (f: (key: string) => string) => <A>(data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    mean: (ns: readonly number[]) => Maybe<number>;
     /**
-     * Removes all `None` values from a `Record<string, Maybe<A>>`, returning a plain `Record<string, A>`.
-     * Useful when building records from fallible lookups.
+     * Computes the minimum of a list of numbers. Returns `None` if the list is empty.
      *
      * @example
      * ```ts
-     * Rec.compact({ a: Maybe.make.some(1), b: Maybe.make.none(), c: Maybe.make.some(3) });
-     * // { a: 1, c: 3 }
+     * Num.min([5, 1, 3]); // Some(1)
+     * Num.min([]);        // None
      * ```
      */
-    const compact: <A>(data: Readonly<Record<string, Maybe<A>>>) => Readonly<Record<string, A>>;
+    min: (ns: readonly number[]) => Maybe<number>;
     /**
-     * Transforms key and value pairs simultaneously.
+     * Computes the maximum of a list of numbers. Returns `None` if the list is empty.
      *
      * @example
      * ```ts
-     * pipe(
-     *   { a: 1, b: 2 },
-     *   Rec.mapEntries((k, v) => [k.toUpperCase(), v * 10])
-     * ); // { A: 10, B: 20 }
+     * Num.max([1, 5, 3]); // Some(5)
+     * Num.max([]);        // None
      * ```
      */
-    const mapEntries: <A, K2 extends string, B>(f: (key: string, value: A) => readonly [K2, B]) => (data: Readonly<Record<string, A>>) => Readonly<Record<K2, B>>;
+    max: (ns: readonly number[]) => Maybe<number>;
     /**
-     * Immutably updates a value at a deep nested path inside a record.
+     * Formats a number using `Intl.NumberFormat`. Returns `None` when `n` is `NaN` or non-finite.
+     * Data-last curried signature.
      *
      * @example
      * ```ts
-     * pipe(
-     *   { user: { profile: { age: 30 } } },
-     *   Rec.updateIn(["user", "profile", "age"], (n: number) => n + 1)
-     * ); // { user: { profile: { age: 31 } } }
+     * const formatCurrency = Num.format({ style: "currency", currency: "USD" }, "en-US");
+     * pipe(1234.5, formatCurrency); // Some("$1,234.50")
+     * pipe(NaN, formatCurrency);    // None
      * ```
      */
-    const updateIn: <T>(path: readonly [string, ...string[]], f: (val: T) => T) => (data: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
-    namespace traverse {
-        const Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Maybe<Readonly<Record<string, B>>>;
-        const Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Readonly<Record<string, A>>) => Result<E, Readonly<Record<string, B>>>;
-    }
-    namespace sequence {
-        const Maybe: <A>(data: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
-        const Result: <E, A>(data: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
-    }
-    const NonEmpty: typeof RecNonEmpty;
-}
+    format: (options?: Intl.NumberFormatOptions, locales?: string | string[]) => (n: number) => Maybe<string>;
+};
 
 /**
- * A branded type representing a string with at least one character.
+ * A branded type representing a record with at least one key-value pair.
  */
-type NonEmptyString = Brand<NonEmpty<"Str">, string>;
+type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">, Readonly<Record<K, A>>>;
 /**
- * String utilities. All transformation functions are data-last and curried so they
- * compose naturally with `pipe`. Safe parsers return `Maybe` instead of `NaN`.
+ * Merges two records using a custom combination function on key collisions.
+ * Supports both uncurried `Rec.mergeWith(combine)(first, second)` and curried `pipe(first, Rec.mergeWith(combine)(second))`.
  *
  * @example
  * ```ts
- * import { Str } from "@nlozgachev/pipelined/data";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * pipe("  Hello, World!  ", Str.trim, Str.toLowerCase); // "hello, world!"
+ * const combineStats = Rec.mergeWith((a: number, b: number) => a + b);
+ * combineStats({ a: 1, b: 2 }, { b: 3, c: 4 }); // { a: 1, b: 5, c: 4 }
+ * pipe({ a: 1, b: 2 }, combineStats({ b: 3, c: 4 })); // { a: 1, b: 5, c: 4 }
  * ```
  */
-declare namespace StrNonEmpty {
-    namespace from {
+declare function mergeWith<A>(combine: (a: A, b: A) => A): {
+    (second: Readonly<Record<string, A>>): (first: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    (first: Readonly<Record<string, A>>, second: Readonly<Record<string, A>>): Readonly<Record<string, A>>;
+};
+declare const Rec: {
+    is: {
+        /**
+         * Returns true if the record has no keys.
+         *
+         * @example
+         * ```ts
+         * Rec.is.empty({});       // true
+         * Rec.is.empty({ a: 1 }); // false
+         * ```
+         */
+        empty: <A>(data: Readonly<Record<string, A>>) => boolean;
+        /**
+         * Type guard to check if a record is non-empty.
+         *
+         * @example
+         * ```ts
+         * Rec.is.nonEmpty({ a: 1 }); // true
+         * Rec.is.nonEmpty({});       // false
+         * ```
+         */
+        nonEmpty: <A, K extends string>(data: Readonly<Record<K, A>>) => data is NonEmptyRecord<A, K>;
+    };
+    from: {
         /**
-         * Returns Some containing NonEmptyString if the string is not empty, None otherwise.
+         * Creates a record from key-value pairs.
          *
          * @example
          * ```ts
-         * Str.NonEmpty.from.String("hello"); // Some("hello")
-         * Str.NonEmpty.from.String("");      // None
+         * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
          * ```
          */
-        const String: (s: string) => Maybe<NonEmptyString>;
-    }
+        entries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    };
+    to: {
+        Dict: <A, K extends string = string>(data: Readonly<Record<K, A>>) => ReadonlyMap<K, A>;
+    };
+    map: <A, B>(f: (a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
+    filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
+    mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
+    filter: <A>(predicate: (a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    filterWithKey: <A>(predicate: (key: string, a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    lookup: <K extends string>(key: K) => <V>(data: Record<string, V>) => Maybe<V>;
+    keys: <T extends Record<string, unknown>>(data: T) => readonly (keyof T & string)[];
+    values: <T extends Record<string, unknown>>(data: T) => readonly T[keyof T & string][];
+    entries: <T extends Record<string, unknown>>(data: T) => readonly (readonly [keyof T, T[keyof T]])[];
+    groupBy: <A>(keyFn: (a: A) => string) => (items: readonly A[]) => Readonly<Record<string, readonly A[]>>;
+    pick: <K extends string>(...pickedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Pick<A, K>;
+    omit: <K extends string>(...omittedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Omit<A, K>;
+    merge: <A>(other: Readonly<Record<string, A>>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    mergeWith: typeof mergeWith;
+    size: <A>(data: Readonly<Record<string, A>>) => number;
+    mapKeys: (f: (key: string) => string) => <A>(data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    compact: <A>(data: Readonly<Record<string, Maybe<A>>>) => Readonly<Record<string, A>>;
+    mapEntries: <A, K2 extends string, B>(f: (key: string, value: A) => readonly [K2, B]) => (data: Readonly<Record<string, A>>) => Readonly<Record<K2, B>>;
+    updateIn: <T>(path: readonly [string, ...string[]], f: (val: T) => T) => (data: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
+    traverse: {
+        Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Maybe<Readonly<Record<string, B>>>;
+        Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Readonly<Record<string, A>>) => Result<E, Readonly<Record<string, B>>>;
+    };
+    sequence: {
+        Maybe: <A>(data: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
+        Result: <E, A>(data: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
+    };
+    NonEmpty: {
+        singleton: <K extends string, A>(key: K, value: A) => NonEmptyRecord<A, K>;
+        from: {
+            Record: <K extends string, A>(data: Readonly<Record<K, A>>) => Maybe<NonEmptyRecord<A, K>>;
+        };
+        keys: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<K>;
+        values: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<A>;
+        entries: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<readonly [K, A]>;
+        reduce: <A>(f: (acc: A, a: A) => A) => <K extends string>(data: NonEmptyRecord<A, K>) => A;
+        map: <A, B>(f: (a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
+        mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
+    };
+};
+declare namespace Rec {
+    type NonEmpty<A, K extends string = string> = NonEmptyRecord<A, K>;
 }
-declare namespace Str {
-    /**
-     * A branded type representing a string with at least one character.
-     */
-    type NonEmpty = NonEmptyString;
-    namespace is {
+
+/**
+ * A branded type representing a string with at least one character.
+ */
+type NonEmptyString = Brand<NonEmpty<"Str">, string>;
+declare const Str: {
+    is: {
         /**
          * Returns `true` when the string is empty.
          *
@@ -2121,12 +820,12 @@ declare namespace Str {
          * pipe("hi", Str.is.empty); // false
          * ```
          */
-        const empty: (s: string) => boolean;
+        empty: (s: string) => boolean;
         /**
          * Type guard to check if a string is non-empty.
          */
-        const nonEmpty: (s: string) => s is NonEmpty;
-    }
+        nonEmpty: (s: string) => s is NonEmptyString;
+    };
     /**
      * Splits a string by a separator. Data-last: use in `pipe`.
      *
@@ -2135,7 +834,7 @@ declare namespace Str {
      * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
      * ```
      */
-    const split: (separator: string | RegExp) => (s: string) => readonly string[];
+    split: (separator: string | RegExp) => (s: string) => readonly string[];
     /**
      * Removes leading and trailing whitespace from a string.
      *
@@ -2144,7 +843,7 @@ declare namespace Str {
      * pipe("  hello  ", Str.trim); // "hello"
      * ```
      */
-    const trim: (s: string) => string;
+    trim: (s: string) => string;
     /**
      * Returns `true` when the string contains the given substring.
      *
@@ -2154,7 +853,7 @@ declare namespace Str {
      * pipe("hello world", Str.includes("xyz"));   // false
      * ```
      */
-    const includes: (substring: string) => (s: string) => boolean;
+    includes: (substring: string) => (s: string) => boolean;
     /**
      * Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
      *
@@ -2164,7 +863,7 @@ declare namespace Str {
      * pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
      * ```
      */
-    const replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+    replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
     /**
      * Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
      *
@@ -2174,7 +873,7 @@ declare namespace Str {
      * pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
      * ```
      */
-    const replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+    replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
     /**
      * Returns `true` when the string starts with the given prefix.
      *
@@ -2184,7 +883,7 @@ declare namespace Str {
      * pipe("hello world", Str.startsWith("world")); // false
      * ```
      */
-    const startsWith: (prefix: string) => (s: string) => boolean;
+    startsWith: (prefix: string) => (s: string) => boolean;
     /**
      * Returns `true` when the string ends with the given suffix.
      *
@@ -2194,7 +893,7 @@ declare namespace Str {
      * pipe("hello world", Str.endsWith("hello")); // false
      * ```
      */
-    const endsWith: (suffix: string) => (s: string) => boolean;
+    endsWith: (suffix: string) => (s: string) => boolean;
     /**
      * Converts a string to uppercase.
      *
@@ -2203,7 +902,7 @@ declare namespace Str {
      * pipe("hello", Str.toUpperCase); // "HELLO"
      * ```
      */
-    const toUpperCase: (s: string) => string;
+    toUpperCase: (s: string) => string;
     /**
      * Converts a string to lowercase.
      *
@@ -2212,7 +911,7 @@ declare namespace Str {
      * pipe("HELLO", Str.toLowerCase); // "hello"
      * ```
      */
-    const toLowerCase: (s: string) => string;
+    toLowerCase: (s: string) => string;
     /**
      * Converts the first character of a string to uppercase.
      *
@@ -2221,7 +920,7 @@ declare namespace Str {
      * pipe("hello", Str.capitalize); // "Hello"
      * ```
      */
-    const capitalize: (s: string) => string;
+    capitalize: (s: string) => string;
     /**
      * Splits a string into lines, normalising `\r\n` and `\r` line endings.
      *
@@ -2231,7 +930,7 @@ declare namespace Str {
      * Str.lines("a\r\nb");         // ["a", "b"]
      * ```
      */
-    const lines: (s: string) => readonly string[];
+    lines: (s: string) => readonly string[];
     /**
      * Splits a string into words on any whitespace boundary, filtering out empty strings.
      *
@@ -2240,7 +939,7 @@ declare namespace Str {
      * Str.words("  hello   world  "); // ["hello", "world"]
      * ```
      */
-    const words: (s: string) => readonly string[];
+    words: (s: string) => readonly string[];
     /**
      * Returns `true` when the string is empty or contains only whitespace.
      *
@@ -2250,7 +949,7 @@ declare namespace Str {
      * pipe("hi", Str.isBlank);  // false
      * ```
      */
-    const isBlank: (s: string) => boolean;
+    isBlank: (s: string) => boolean;
     /**
      * Returns the length of the string.
      *
@@ -2260,7 +959,7 @@ declare namespace Str {
      * pipe("", Str.length);      // 0
      * ```
      */
-    const length: (s: string) => number;
+    length: (s: string) => number;
     /**
      * Extracts a substring between two indices. Data-last: use in `pipe`.
      *
@@ -2270,7 +969,7 @@ declare namespace Str {
      * pipe("hello", Str.slice(2));    // "llo"
      * ```
      */
-    const slice: (start: number, end?: number) => (s: string) => string;
+    slice: (start: number, end?: number) => (s: string) => string;
     /**
      * Pads the start of a string to a specified length. Data-last: use in `pipe`.
      *
@@ -2280,7 +979,7 @@ declare namespace Str {
      * pipe("hi", Str.padStart(5));     // "   hi"
      * ```
      */
-    const padStart: (maxLength: number, fillString?: string) => (s: string) => string;
+    padStart: (maxLength: number, fillString?: string) => (s: string) => string;
     /**
      * Pads the end of a string to a specified length. Data-last: use in `pipe`.
      *
@@ -2290,11 +989,11 @@ declare namespace Str {
      * pipe("hi", Str.padEnd(5));       // "hi   "
      * ```
      */
-    const padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
+    padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
     /**
      * Safe number parsers that return `Maybe` instead of `NaN`.
      */
-    const parse: {
+    parse: {
         /**
          * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
          *
@@ -2327,7 +1026,7 @@ declare namespace Str {
      * Str.parseJson('invalid');  // Err(SyntaxError)
      * ```
      */
-    const parseJson: (s: string) => Result<SyntaxError, unknown>;
+    parseJson: (s: string) => Result<SyntaxError, unknown>;
     /**
      * Converts the first character of a string to lower case.
      *
@@ -2337,7 +1036,7 @@ declare namespace Str {
      * Str.uncapitalize("");      // ""
      * ```
      */
-    const uncapitalize: (s: string) => string;
+    uncapitalize: (s: string) => string;
     /**
      * Truncates a string to a maximum length, appending an optional suffix (default `"..."`).
      * Data-last curried signature.
@@ -2349,267 +1048,80 @@ declare namespace Str {
      * pipe("Hello, world!", Str.truncate({ length: 8, suffix: "…" })); // "Hello, w…"
      * ```
      */
-    const truncate: (options: {
+    truncate: (options: {
         length: number;
         suffix?: string;
     }) => (s: string) => string;
-    const NonEmpty: typeof StrNonEmpty;
+    NonEmpty: {
+        from: {
+            /**
+             * Returns Some containing NonEmptyString if the string is not empty, None otherwise.
+             *
+             * @example
+             * ```ts
+             * Str.NonEmpty.from.String("hello"); // Some("hello")
+             * Str.NonEmpty.from.String("");      // None
+             * ```
+             */
+            String: (s: string) => Maybe<NonEmptyString>;
+        };
+    };
+};
+declare namespace Str {
+    /**
+     * A branded type representing a string with at least one character.
+     */
+    type NonEmpty = NonEmptyString;
 }
 
 /**
  * A branded type representing a unique collection with at least one element.
  */
 type NonEmptySet<A> = Brand<NonEmpty<"Uniq">, ReadonlySet<A>>;
-/**
- * Functional utilities for unique-value collections (`ReadonlySet<A>`). All functions are pure
- * and data-last — they compose naturally with `pipe`.
- *
- * Every "mutating" operation returns a new set; the original is never changed.
- *
- * @example
- * ```ts
- * import { Uniq } from "@nlozgachev/pipelined/data";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const active = pipe(
- *   Uniq.from.Array(["alice", "bob", "alice", "carol"]),
- *   Uniq.remove("bob"),
- *   Uniq.map(name => name.toUpperCase()),
- * );
- * // ReadonlySet { "ALICE", "CAROL" }
- * ```
- */
-declare namespace UniqNonEmpty {
-    /**
-     * Creates a single-element unique collection.
-     *
-     * @example
-     * ```ts
-     * Uniq.NonEmpty.singleton(42); // ReadonlySet { 42 }
-     * ```
-     */
-    const singleton: <A>(item: A) => NonEmptySet<A>;
-    namespace from {
-        /**
-         * Returns Some containing NonEmptySet if the set is not empty, None otherwise.
-         *
-         * @example
-         * ```ts
-         * Uniq.NonEmpty.from.Set(Uniq.from.Array([1, 2])); // Some(ReadonlySet { 1, 2 })
-         * Uniq.NonEmpty.from.Set(Uniq.empty());           // None
-         * ```
-         */
-        const Set: <A>(s: ReadonlySet<A>) => Maybe<NonEmptySet<A>>;
-    }
-    /**
-     * Folds the collection into a single value without an initial seed value.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.NonEmpty.singleton(42), Uniq.NonEmpty.reduce((a, b) => a + b)); // 42
-     * ```
-     */
-    const reduce: <A>(f: (acc: A, a: A) => A) => (s: NonEmptySet<A>) => A;
-    /**
-     * Transforms each item in the non-empty unique collection.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.NonEmpty.singleton(1), Uniq.NonEmpty.map(n => n * 2)); // ReadonlySet { 2 }
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => (s: NonEmptySet<A>) => NonEmptySet<B>;
-    namespace to {
-        /**
-         * Converts the collection to a non-empty readonly array in insertion order.
-         *
-         * @example
-         * ```ts
-         * Uniq.NonEmpty.to.Array(Uniq.NonEmpty.singleton(42)); // [42]
-         * ```
-         */
-        const Array: <A>(s: NonEmptySet<A>) => NonEmptyArr<A>;
-    }
-}
+declare const Uniq: {
+    is: {
+        empty: <A>(s: ReadonlySet<A>) => boolean;
+        nonEmpty: <A>(s: ReadonlySet<A>) => s is NonEmptySet<A>;
+    };
+    empty: <A>() => ReadonlySet<A>;
+    singleton: <A>(item: A) => ReadonlySet<A>;
+    from: {
+        Array: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    };
+    has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
+    size: <A>(s: ReadonlySet<A>) => number;
+    add: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    insert: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    remove: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    toggle: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    map: <A, B>(f: (a: A) => B) => (s: ReadonlySet<A>) => ReadonlySet<B>;
+    filter: <A>(predicate: (a: A) => boolean) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    filterMap: <A, B>(f: (a: A) => Maybe<B>) => (s: ReadonlySet<A>) => ReadonlySet<B>;
+    union: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    intersection: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    difference: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    isSubsetOf: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => boolean;
+    reduce: <A, B>(init: B, f: (acc: B, a: A) => B) => (s: ReadonlySet<A>) => B;
+    to: {
+        Array: <A>(s: ReadonlySet<A>) => readonly A[];
+    };
+    NonEmpty: {
+        singleton: <A>(item: A) => NonEmptySet<A>;
+        from: {
+            Set: <A>(s: ReadonlySet<A>) => Maybe<NonEmptySet<A>>;
+        };
+        reduce: <A>(f: (acc: A, a: A) => A) => (s: NonEmptySet<A>) => A;
+        map: <A, B>(f: (a: A) => B) => (s: NonEmptySet<A>) => NonEmptySet<B>;
+        to: {
+            Array: <A>(s: NonEmptySet<A>) => NonEmptyArr<A>;
+        };
+    };
+};
 declare namespace Uniq {
     /**
      * A branded type representing a unique collection with at least one element.
      */
     type NonEmpty<A> = NonEmptySet<A>;
-    namespace is {
-        /**
-         * Returns `true` if the collection has no items.
-         *
-         * @example
-         * ```ts
-         * Uniq.is.empty(Uniq.empty()); // true
-         * ```
-         */
-        const empty: <A>(s: ReadonlySet<A>) => boolean;
-        /**
-         * Type guard to check if a unique collection is non-empty.
-         *
-         * @example
-         * ```ts
-         * Uniq.is.nonEmpty(Uniq.from.Array([1, 2])); // true
-         * Uniq.is.nonEmpty(Uniq.empty());            // false
-         * ```
-         */
-        const nonEmpty: <A>(s: ReadonlySet<A>) => s is NonEmpty<A>;
-    }
-    /**
-     * Creates an empty unique collection.
-     *
-     * @example
-     * ```ts
-     * Uniq.empty<number>(); // ReadonlySet {}
-     * ```
-     */
-    const empty: <A>() => ReadonlySet<A>;
-    /**
-     * Creates a unique collection containing a single item.
-     *
-     * @example
-     * ```ts
-     * Uniq.singleton(42); // ReadonlySet { 42 }
-     * ```
-     */
-    const singleton: <A>(item: A) => ReadonlySet<A>;
-    namespace from {
-        /**
-         * Creates a unique collection from an array, automatically discarding duplicates.
-         *
-         * @example
-         * ```ts
-         * Uniq.from.Array([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
-         * Uniq.from.Array([]);                  // ReadonlySet {}
-         * ```
-         */
-        const Array: <A>(arr: readonly A[]) => ReadonlySet<A>;
-    }
-    /**
-     * Returns `true` if the collection contains the given item.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.has(2)); // true
-     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.has(4)); // false
-     * ```
-     */
-    const has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
-    /**
-     * Returns the number of items in the collection.
-     *
-     * @example
-     * ```ts
-     * Uniq.size(Uniq.from.Array([1, 2, 3])); // 3
-     * ```
-     */
-    const size: <A>(s: ReadonlySet<A>) => number;
-    /**
-     * Returns `true` if every item in `set` also exists in `other`.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2]), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3]))); // true
-     * pipe(Uniq.from.Array([1, 4]), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3]))); // false
-     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3])));   // true
-     * ```
-     */
-    const isSubsetOf: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => boolean;
-    /**
-     * Returns a new collection with the item added. If the item is already present, returns the
-     * original collection unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
-     * pipe(Uniq.from.Array([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
-     * ```
-     */
-    const insert: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-    /**
-     * Returns a new collection with the item removed. If the item is not present, returns the
-     * original collection unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
-     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
-     * ```
-     */
-    const remove: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-    /**
-     * Applies `f` to each item, returning a new collection of the results. Duplicate results are
-     * automatically merged.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => (s: ReadonlySet<A>) => ReadonlySet<B>;
-    /**
-     * Returns a new collection containing only the items for which the predicate returns `true`.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
-     * // ReadonlySet { 2, 4 }
-     * ```
-     */
-    const filter: <A>(predicate: (a: A) => boolean) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-    /**
-     * Returns a new collection containing all items from both collections.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.union(Uniq.from.Array([2, 3, 4])));
-     * // ReadonlySet { 1, 2, 3, 4 }
-     * ```
-     */
-    const union: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-    /**
-     * Returns a new collection containing only the items that appear in both collections.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.intersection(Uniq.from.Array([2, 3, 4])));
-     * // ReadonlySet { 2, 3 }
-     * ```
-     */
-    const intersection: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-    /**
-     * Returns a new collection containing only the items from `set` that do not appear in `other`.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.from.Array([1, 2, 3, 4]), Uniq.difference(Uniq.from.Array([2, 4])));
-     * // ReadonlySet { 1, 3 }
-     * ```
-     */
-    const difference: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-    /**
-     * Folds the collection into a single value by applying `f` to each item in insertion order.
-     *
-     * @example
-     * ```ts
-     * Uniq.reduce(0, (acc, n: number) => acc + n)(Uniq.from.Array([1, 2, 3])); // 6
-     * ```
-     */
-    const reduce: <A, B>(init: B, f: (acc: B, a: A) => B) => (s: ReadonlySet<A>) => B;
-    namespace to {
-        /**
-         * Converts the collection to a readonly array in insertion order.
-         *
-         * @example
-         * ```ts
-         * Uniq.to.Array(Uniq.from.Array([3, 1, 2])); // [3, 1, 2]
-         * ```
-         */
-        const Array: <A>(s: ReadonlySet<A>) => readonly A[];
-    }
-    const NonEmpty: typeof UniqNonEmpty;
 }
 
 export { Arr, BigNum, Dict, Json, type NonEmptyMap, type NonEmptyRecord, type NonEmptySet, type NonEmptyString, Num, Rec, Str, Uniq };