@nlozgachev/pipelined 0.63.0 → 0.65.0

package/dist/data.d.ts

@@ -1,144 +1,144 @@
-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';
-
+import { r as Brand } from "./index-Bs8En5LJ.js";
+import { n as NonEmpty, r as NonEmptyArr } from "./InternalTypes-DzDey5Do.js";
+import { D as Maybe, N as Equality, a as Task, p as Result, w as Ordering } from "./index-B07Wr815.js";
+//#region src/Data/Arr.d.ts
 declare namespace ArrTaskResult {
-    /**
-     * Maps each element to a Task.Result and runs them sequentially.
-     * Returns the first Err encountered, or Ok of all results if all succeed.
-     *
-     * @example
-     * ```ts
-     * const validate = (n: number): Task.Result<string, number> =>
-     *   n > 0 ? Task.Result.ok(n) : Task.Result.err("non-positive");
-     *
-     * pipe(
-     *   [1, 2, 3],
-     *   Arr.traverse.Task.Result(validate)
-     * )(); // Deferred<Ok([1, 2, 3])>
-     *
-     * pipe(
-     *   [1, -1, 3],
-     *   Arr.traverse.Task.Result(validate)
-     * )(); // Deferred<Err("non-positive")>
-     * ```
-     */
-    const traverse: <E, A, B>(f: (a: A) => Task<Result<E, B>>) => (data: readonly A[]) => Task<Result<E, readonly B[]>>;
-    /**
-     * Collects an array of Task.Results into a Task.Result of array.
-     * Returns the first Err if any element is Err, runs sequentially.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [Task.Result.ok(1), Task.Result.ok(2)],
-     *   Arr.sequence.Task.Result
-     * )(); // Deferred<Ok([1, 2])>
-     * ```
-     */
-    const sequence: <E, A>(data: readonly Task<Result<E, A>>[]) => Task<Result<E, readonly A[]>>;
+  /**
+   * Maps each element to a Task.Result and runs them sequentially.
+   * Returns the first Err encountered, or Ok of all results if all succeed.
+   *
+   * @example
+   * ```ts
+   * const validate = (n: number): Task.Result<string, number> =>
+   *   n > 0 ? Task.Result.ok(n) : Task.Result.err("non-positive");
+   *
+   * pipe(
+   *   [1, 2, 3],
+   *   Arr.traverse.Task.Result(validate)
+   * )(); // Deferred<Ok([1, 2, 3])>
+   *
+   * pipe(
+   *   [1, -1, 3],
+   *   Arr.traverse.Task.Result(validate)
+   * )(); // Deferred<Err("non-positive")>
+   * ```
+   */
+  const traverse: <E, A, B>(f: (a: A) => Task.Result<E, B>) => (data: readonly A[]) => Task.Result<E, readonly B[]>;
+  /**
+   * Collects an array of Task.Results into a Task.Result of array.
+   * Returns the first Err if any element is Err, runs sequentially.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   [Task.Result.ok(1), Task.Result.ok(2)],
+   *   Arr.sequence.Task.Result
+   * )(); // Deferred<Ok([1, 2])>
+   * ```
+   */
+  const sequence: <E, A>(data: readonly Task.Result<E, A>[]) => Task.Result<E, readonly A[]>;
 }
 interface TaskTraverse {
-    <A, B>(f: (a: A) => Task<B>): (data: readonly A[]) => Task<readonly B[]>;
-    Result: typeof ArrTaskResult.traverse;
+  <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;
+  <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[];
+export 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>>;
-    };
-    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>;
+      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>;
+export declare namespace Arr {
+  type NonEmpty<A> = NonEmptyArr<A>;
 }
-
+//#endregion
+//#region src/Data/BigNum.d.ts
 /**
  * Safe conversion and arithmetic utilities for arbitrary-precision integers (`bigint`).
  * All functions are pure and data-last to compose cleanly with `pipe`.
@@ -154,561 +154,907 @@ declare namespace Arr {
  * ); // Some(150n)
  * ```
  */
-declare const BigNum: {
-    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
-         * ```
-         */
-        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
-         * ```
-         */
-        number: (n: number) => Maybe<bigint>;
-    };
-    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
-         * ```
-         */
-        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
-     * ```
-     */
-    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
-     * ```
-     */
-    sub: (b: bigint) => (a: bigint) => bigint;
+export declare const BigNum: {
+  is: {
     /**
-     * Multiplies `a` by `b`. Data-last curried signature: `mul(b)(a)` = `a * b`.
+     * Returns `true` when the bigint is equal to zero (`0n`).
      *
      * @example
      * ```ts
-     * pipe(6n, BigNum.mul(7n)); // 42n
+     * BigNum.is.zero(0n); // true
+     * BigNum.is.zero(5n); // false
      * ```
      */
-    mul: (b: bigint) => (a: bigint) => bigint;
+    zero: (b: bigint) => boolean;
     /**
-     * Divides `a` by `b`. Returns `None` if `b` is `0n`.
+     * Returns `true` when the bigint is an even integer.
      *
      * @example
      * ```ts
-     * pipe(20n, BigNum.div(4n)); // Some(5n)
-     * pipe(5n, BigNum.div(0n));  // None
+     * BigNum.is.even(4n); // true
+     * BigNum.is.even(3n); // false
      * ```
      */
-    div: (b: bigint) => (a: bigint) => Maybe<bigint>;
+    even: (b: bigint) => boolean;
     /**
-     * Computes remainder of `a / b`. Returns `None` if `b` is `0n`.
+     * Returns `true` when the bigint is an odd integer.
      *
      * @example
      * ```ts
-     * pipe(10n, BigNum.mod(3n)); // Some(1n)
-     * pipe(5n, BigNum.mod(0n));  // None
+     * BigNum.is.odd(3n); // true
+     * BigNum.is.odd(4n); // false
      * ```
      */
-    mod: (b: bigint) => (a: bigint) => Maybe<bigint>;
+    odd: (b: bigint) => boolean;
     /**
-     * Clamps `a` between `min` and `max` (inclusive).
+     * Returns `true` when the bigint is strictly greater than zero (`0n`).
      *
      * @example
      * ```ts
-     * pipe(150n, BigNum.clamp(0n, 100n)); // 100n
+     * BigNum.is.positive(5n);  // true
+     * BigNum.is.positive(0n);  // false
+     * BigNum.is.positive(-5n); // false
      * ```
      */
-    clamp: (min: bigint, max: bigint) => (a: bigint) => bigint;
+    positive: (b: bigint) => boolean;
     /**
-     * Returns `true` if `a` is in the range `[start, end)` (inclusive start, exclusive end).
+     * Returns `true` when the bigint is strictly less than zero (`0n`).
      *
      * @example
      * ```ts
-     * pipe(5n, BigNum.inRange(1n, 10n)); // true
+     * BigNum.is.negative(-5n); // true
+     * BigNum.is.negative(0n);  // false
+     * BigNum.is.negative(5n);  // false
      * ```
      */
-    inRange: (start: bigint, end: bigint) => (a: bigint) => boolean;
+    negative: (b: bigint) => boolean;
+  };
+  from: {
     /**
-     * Returns absolute value of a `bigint`.
+     * Safely parses a string into a `bigint`. Returns `None` if parsing fails.
      *
      * @example
      * ```ts
-     * BigNum.abs(-42n); // 42n
+     * BigNum.from.string("123"); // Some(123n)
+     * BigNum.from.string("abc"); // None
      * ```
      */
-    abs: (a: bigint) => bigint;
+    string: (s: string) => Maybe<bigint>;
     /**
-     * Returns the minimum of `a` and `b`.
+     * Safely converts a number into a `bigint`. Returns `None` for floats, `NaN`, or non-safe integers.
      *
      * @example
      * ```ts
-     * pipe(10n, BigNum.min(5n)); // 5n
+     * BigNum.from.number(42);   // Some(42n)
+     * BigNum.from.number(3.14); // None
      * ```
      */
-    min: (b: bigint) => (a: bigint) => bigint;
+    number: (n: number) => Maybe<bigint>;
+  };
+  to: {
     /**
-     * Returns the maximum of `a` and `b`.
+     * Safely converts a `bigint` to a `number`. Returns `None` if the value is outside JavaScript's safe integer range.
      *
      * @example
      * ```ts
-     * pipe(10n, BigNum.max(5n)); // 10n
+     * BigNum.to.number(42n);                    // Some(42)
+     * BigNum.to.number(9007199254740993n);      // None
      * ```
      */
-    max: (b: bigint) => (a: bigint) => bigint;
+    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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  mod: (b: bigint) => (a: bigint) => Maybe<bigint>;
+  /**
+   * Clamps `a` between `min` and `max` (inclusive).
+   *
+   * @example
+   * ```ts
+   * pipe(150n, BigNum.clamp(0n, 100n)); // 100n
+   * ```
+   */
+  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
+   * ```
+   */
+  inRange: (start: bigint, end: bigint) => (a: bigint) => boolean;
+  /**
+   * Returns absolute value of a `bigint`.
+   *
+   * @example
+   * ```ts
+   * BigNum.abs(-42n); // 42n
+   * ```
+   */
+  abs: (a: bigint) => bigint;
+  /**
+   * Returns the minimum of `a` and `b`.
+   *
+   * @example
+   * ```ts
+   * pipe(10n, BigNum.min(5n)); // 5n
+   * ```
+   */
+  min: (b: bigint) => (a: bigint) => bigint;
+  /**
+   * Returns the maximum of `a` and `b`.
+   *
+   * @example
+   * ```ts
+   * pipe(10n, BigNum.max(5n)); // 10n
+   * ```
+   */
+  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>;
+//#endregion
+//#region src/Data/Bool.d.ts
+export type BoolMatchCases<A, B> = {
+  readonly true: () => A;
+  readonly false: () => B;
 };
-declare const Dict: {
-    is: {
-        empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
-        nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmptyMap<K, V>;
-    };
-    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.
-     */
-    type NonEmpty<K, V> = NonEmptyMap<K, V>;
-}
-
-/**
- * Pure, non-throwing JSON utilities.
- * Wraps runtime JSON parsing and stringifying in typed `Result` containers.
- *
- * @example
- * ```ts
- * import { Json } from "@nlozgachev/pipelined/data";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const result = pipe(
- *   Json.parse('{"name":"Alice"}'),
- *   Result.map((data: any) => data.name)
- * ); // Ok("Alice")
- * ```
- */
-declare const Json: {
+export declare const Bool: {
+  is: {
     /**
-     * Safely parses a JSON string into `unknown`.
-     * Converts thrown exceptions into a `Result<SyntaxError, unknown>`.
+     * Type guard — checks if a value is a primitive boolean.
      *
      * @example
      * ```ts
-     * Json.parse('{"a": 1}'); // Ok({ a: 1 })
-     * Json.parse('{invalid}'); // Err(SyntaxError)
+     * Bool.is.boolean(true);      // true
+     * Bool.is.boolean(false);     // true
+     * Bool.is.boolean("true");    // false
+     * Bool.is.boolean(null);      // false
      * ```
      */
-    parse: (text: string) => Result<SyntaxError, unknown>;
+    boolean: (u: unknown) => u is boolean;
     /**
-     * Safely stringifies a value into a JSON string.
-     * Converts thrown exceptions (e.g. circular references) into a `Result<TypeError, string>`.
+     * Narrowing guard — checks if a value is strictly `true`.
      *
      * @example
      * ```ts
-     * Json.stringify({ a: 1 }); // Ok('{"a":1}')
+     * Bool.is.true(true);  // true
+     * Bool.is.true(false); // false
      * ```
      */
-    stringify: (value: unknown, replacer?: (this: any, key: string, value: any) => any, space?: string | number) => Result<TypeError, string>;
-};
-
-declare const Num: {
-    is: {
-        /**
-         * Returns `true` when the number is equal to zero.
-         *
-         * @example
-         * ```ts
-         * Num.is.zero(0); // true
-         * Num.is.zero(5); // false
-         * ```
-         */
-        zero: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is a whole integer.
-         *
-         * @example
-         * ```ts
-         * Num.is.integer(5);    // true
-         * Num.is.integer(3.14); // false
-         * ```
-         */
-        integer: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is a finite float (fractional number).
-         *
-         * @example
-         * ```ts
-         * Num.is.float(3.14); // true
-         * Num.is.float(5);    // false
-         * ```
-         */
-        float: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is finite (not `Infinity`, `-Infinity`, or `NaN`).
-         *
-         * @example
-         * ```ts
-         * Num.is.finite(42);       // true
-         * Num.is.finite(Infinity); // false
-         * ```
-         */
-        finite: (n: number) => boolean;
-        /**
-         * Returns `true` when the value is `NaN`.
-         *
-         * @example
-         * ```ts
-         * Num.is.nan(NaN); // true
-         * Num.is.nan(42);  // false
-         * ```
-         */
-        nan: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is an even integer.
-         *
-         * @example
-         * ```ts
-         * Num.is.even(4);   // true
-         * Num.is.even(3);   // false
-         * Num.is.even(2.5); // false
-         * ```
-         */
-        even: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is an odd integer.
-         *
-         * @example
-         * ```ts
-         * Num.is.odd(3);   // true
-         * Num.is.odd(4);   // false
-         * Num.is.odd(2.5); // false
-         * ```
-         */
-        odd: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is strictly greater than zero.
-         *
-         * @example
-         * ```ts
-         * Num.is.positive(5);  // true
-         * Num.is.positive(0);  // false
-         * Num.is.positive(-5); // false
-         * ```
-         */
-        positive: (n: number) => boolean;
-        /**
-         * Returns `true` when the number is strictly less than zero.
-         *
-         * @example
-         * ```ts
-         * Num.is.negative(-5); // true
-         * Num.is.negative(0);  // false
-         * Num.is.negative(5);  // false
-         * ```
-         */
-        negative: (n: number) => boolean;
-    };
+    true: (u: unknown) => u is true;
     /**
-     * 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`,
-     * returns an empty array. When `step` does not land exactly on `to`, the last value
-     * is the largest reachable value that does not exceed `to`.
+     * Narrowing guard — checks if a value is strictly `false`.
      *
      * @example
      * ```ts
-     * Num.range(0, 5);       // [0, 1, 2, 3, 4, 5]
-     * Num.range(0, 10, 2);   // [0, 2, 4, 6, 8, 10]
-     * Num.range(0, 9, 2);    // [0, 2, 4, 6, 8]
-     * Num.range(5, 0);       // []
-     * Num.range(3, 3);       // [3]
+     * Bool.is.false(false); // true
+     * Bool.is.false(true);  // false
      * ```
      */
-    range: (from: number, to: number, step?: number) => readonly number[];
+    false: (u: unknown) => u is false;
     /**
-     * Clamps a number between `min` and `max` (both inclusive).
+     * Type guard — checks if a value is truthy (not `false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
      *
      * @example
      * ```ts
-     * pipe(150, Num.clamp(0, 100)); // 100
-     * pipe(-5, Num.clamp(0, 100));  // 0
-     * pipe(42, Num.clamp(0, 100));  // 42
+     * Bool.is.truthy("hello"); // true
+     * Bool.is.truthy(42);      // true
+     * Bool.is.truthy(0);       // false
+     * Bool.is.truthy(null);    // false
      * ```
      */
-    clamp: (min: number, max: number) => (n: number) => number;
+    truthy: <T>(u: T) => u is Exclude<T, false | 0 | 0n | "" | null | undefined>;
     /**
-     * Returns `true` when the number is between `min` and `max` (both inclusive).
+     * Type guard — checks if a value is falsy (`false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
      *
      * @example
      * ```ts
-     * pipe(5, Num.between(1, 10));  // true
-     * pipe(0, Num.between(1, 10));  // false
-     * pipe(10, Num.between(1, 10)); // true
+     * Bool.is.falsy("");        // true
+     * Bool.is.falsy(null);      // true
+     * Bool.is.falsy("content"); // false
      * ```
      */
-    between: (min: number, max: number) => (n: number) => boolean;
+    falsy: (u: unknown) => u is false | 0 | 0n | "" | null | undefined;
+  };
+  /**
+   * Unary boolean negation: inverts the given boolean value.
+   *
+   * @example
+   * ```ts
+   * Bool.not(true);  // false
+   * Bool.not(false); // true
+   * ```
+   */
+  not: (b: boolean) => boolean;
+  /**
+   * Logical AND combinator. Returns `true` only if both `self` and `that` are `true`.
+   *
+   * Data-last: `pipe(self, Bool.and(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(true, Bool.and(true));  // true
+   * pipe(true, Bool.and(false)); // false
+   * ```
+   */
+  and: (that: boolean) => (self: boolean) => boolean;
+  /**
+   * Logical OR combinator. Returns `true` if either `self` or `that` is `true`.
+   *
+   * Data-last: `pipe(self, Bool.or(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(false, Bool.or(true));  // true
+   * pipe(false, Bool.or(false)); // false
+   * ```
+   */
+  or: (that: boolean) => (self: boolean) => boolean;
+  /**
+   * Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `self` and `that` is `true`.
+   *
+   * Data-last: `pipe(self, Bool.xor(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(true, Bool.xor(false)); // true
+   * pipe(true, Bool.xor(true));  // false
+   * ```
+   */
+  xor: (that: boolean) => (self: boolean) => boolean;
+  /**
+   * Lazy logical AND combinator.
+   * If `self` is `false`, the `that` computation is never evaluated.
+   *
+   * Data-last: `pipe(self, Bool.andLazy(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isCached,
+   *   Bool.andLazy(() => checkPermissions())
+   * );
+   * ```
+   */
+  andLazy: (that: () => boolean) => (self: boolean) => boolean;
+  /**
+   * Lazy logical OR combinator.
+   * If `self` is `true`, the `that` computation is never evaluated.
+   *
+   * Data-last: `pipe(self, Bool.orLazy(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isAdmin,
+   *   Bool.orLazy(() => hasAccess(userId))
+   * );
+   * ```
+   */
+  orLazy: (that: () => boolean) => (self: boolean) => boolean;
+  /**
+   * N-ary AND aggregation across an array of booleans.
+   * Returns `true` if every boolean is `true`, or for an empty array (vacuous truth).
+   * Short-circuits on the first `false`.
+   *
+   * @example
+   * ```ts
+   * Bool.all([true, true, true]);  // true
+   * Bool.all([true, false, true]); // false
+   * Bool.all([]);                  // true
+   * ```
+   */
+  all: (booleans: readonly boolean[]) => boolean;
+  /**
+   * N-ary OR aggregation across an array of booleans.
+   * Returns `true` if at least one boolean is `true`. Returns `false` for an empty array.
+   * Short-circuits on the first `true`.
+   *
+   * @example
+   * ```ts
+   * Bool.any([false, true, false]); // true
+   * Bool.any([false, false]);       // false
+   * Bool.any([]);                   // false
+   * ```
+   */
+  any: (booleans: readonly boolean[]) => boolean;
+  /**
+   * Catamorphism for boolean: evaluates `onFalse()` when `false` and `onTrue()` when `true`.
+   *
+   * Positional ordering: `onFalse` first, `onTrue` second.
+   * Aligned with `Result.fold(onErr, onOk)` and `Maybe.fold(onNone, onSome)`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isDarkMode,
+   *   Bool.fold(
+   *     () => "light-theme",
+   *     () => "dark-theme"
+   *   )
+   * );
+   * ```
+   */
+  fold: <A, B>(onFalse: () => A, onTrue: () => B) => (b: boolean) => A | B;
+  /**
+   * Pattern matching on boolean using named cases `{ true, false }`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isEnabled,
+   *   Bool.match({
+   *     true: () => "Feature Active",
+   *     false: () => "Feature Disabled",
+   *   })
+   * );
+   * ```
+   */
+  match: <A, B>(cases: BoolMatchCases<A, B>) => (b: boolean) => A | B;
+  from: {
     /**
-     * Returns `true` when the number is in the range `[start, end)` (inclusive of `start`, exclusive of `end`).
+     * Parses a string into a `Maybe<boolean>`.
+     * Returns `Some(true)` for `"true"`, `Some(false)` for `"false"` (case-insensitive & trimmed),
+     * and `None` for any other string.
      *
      * @example
      * ```ts
-     * pipe(5, Num.inRange(1, 10));  // true
-     * pipe(1, Num.inRange(1, 10));  // true
-     * pipe(10, Num.inRange(1, 10)); // false
+     * Bool.from.string("true");  // Some(true)
+     * Bool.from.string("FALSE"); // Some(false)
+     * Bool.from.string("yes");   // None
      * ```
      */
-    inRange: (start: number, end: number) => (n: number) => boolean;
+    string: (s: string) => Maybe<boolean>;
     /**
-     * Parses a string as a number. Returns `None` when the result is `NaN`.
+     * Converts a number into a `Maybe<boolean>`.
+     * Returns `Some(true)` for `1`, `Some(false)` for `0`, and `None` for any other number.
      *
      * @example
      * ```ts
-     * Num.parse("42");   // Some(42)
-     * Num.parse("3.14"); // Some(3.14)
-     * Num.parse("abc");  // None
-     * Num.parse("");     // None
+     * Bool.from.number(1);  // Some(true)
+     * Bool.from.number(0);  // Some(false)
+     * Bool.from.number(42); // None
      * ```
      */
-    parse: (s: string) => Maybe<number>;
+    number: (n: number) => Maybe<boolean>;
     /**
-     * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
+     * Coerces any unknown value into a boolean via standard JS `Boolean(value)`.
      *
      * @example
      * ```ts
-     * pipe(5, Num.add(3));                   // 8
-     * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
+     * Bool.from.truthy("hello"); // true
+     * Bool.from.truthy(0);       // false
      * ```
      */
-    add: (b: number) => (a: number) => number;
+    truthy: (value: unknown) => boolean;
+  };
+  to: {
     /**
-     * Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
+     * Lifts a boolean condition into a `Maybe`.
+     * Returns `Some(onTrue())` when `true`, and `None` when `false`.
      *
      * @example
      * ```ts
-     * pipe(10, Num.subtract(3));                  // 7
-     * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
-     * ```
-     */
-    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]
+     * pipe(
+     *   user.isVerified,
+     *   Bool.to.Maybe(() => user.profile)
+     * ); // Some(profile) or None
      * ```
      */
-    multiply: (b: number) => (a: number) => number;
+    Maybe: <A>(onTrue: () => A) => (b: boolean) => Maybe<A>;
     /**
-     * Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
+     * Lifts a boolean condition into a `Result`.
+     * Returns `Ok(onOk())` when `true`, and `Err(onErr())` when `false`.
      *
      * @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]
+     * pipe(
+     *   hasPermission,
+     *   Bool.to.Result(
+     *     () => "Permission denied",
+     *     () => sessionData
+     *   )
+     * ); // Ok(sessionData) or Err("Permission denied")
      * ```
      */
-    divide: (b: number) => (a: number) => Maybe<number>;
+    Result: <E, A>(onErr: () => E, onOk: () => A) => (b: boolean) => Result<E, A>;
     /**
-     * Returns the absolute value of a number.
+     * Converts a boolean to numeric `1` or `0`.
      *
      * @example
      * ```ts
-     * pipe(-5, Num.abs); // 5
-     * pipe(5, Num.abs);  // 5
+     * Bool.to.number(true);  // 1
+     * Bool.to.number(false); // 0
      * ```
      */
-    abs: (n: number) => number;
+    number: (b: boolean) => 1 | 0;
     /**
-     * Negates a number (arithmetic negation).
+     * Converts a boolean to literal string `"true"` or `"false"`.
      *
      * @example
      * ```ts
-     * pipe(5, Num.negate);  // -5
-     * pipe(-5, Num.negate); // 5
+     * Bool.to.string(true);  // "true"
+     * Bool.to.string(false); // "false"
      * ```
      */
-    negate: (n: number) => number;
+    string: (b: boolean) => "true" | "false";
+  };
+};
+//#endregion
+//#region src/Data/Dict.d.ts
+/**
+ * A branded type representing a key-value dictionary with at least one entry.
+ */
+export 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>;
+};
+export declare const Dict: {
+  is: {
+    empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
+    nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmptyMap<K, V>;
+  };
+  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>;
+  };
+};
+export declare namespace Dict {
+  /**
+   * A branded type representing a key-value dictionary with at least one entry.
+   */
+  type NonEmpty<K, V> = NonEmptyMap<K, V>;
+}
+//#endregion
+//#region src/Data/Json.d.ts
+/**
+ * Pure, non-throwing JSON utilities.
+ * Wraps runtime JSON parsing and stringifying in typed `Result` containers.
+ *
+ * @example
+ * ```ts
+ * import { Json } from "@nlozgachev/pipelined/data";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const result = pipe(
+ *   Json.parse('{"name":"Alice"}'),
+ *   Result.map((data: any) => data.name)
+ * ); // Ok("Alice")
+ * ```
+ */
+export declare const Json: {
+  /**
+   * Safely parses a JSON string into `unknown`.
+   * Converts thrown exceptions into a `Result<SyntaxError, unknown>`.
+   *
+   * @example
+   * ```ts
+   * Json.parse('{"a": 1}'); // Ok({ a: 1 })
+   * Json.parse('{invalid}'); // Err(SyntaxError)
+   * ```
+   */
+  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>`.
+   *
+   * @example
+   * ```ts
+   * Json.stringify({ a: 1 }); // Ok('{"a":1}')
+   * ```
+   */
+  stringify: (value: unknown, replacer?: (this: any, key: string, value: any) => any, space?: string | number) => Result<TypeError, string>;
+};
+//#endregion
+//#region src/Data/Num.d.ts
+export declare const Num: {
+  is: {
     /**
-     * Rounds a number to the nearest integer.
+     * Returns `true` when the number is equal to zero.
      *
      * @example
      * ```ts
-     * pipe(3.5, Num.round); // 4
-     * pipe(3.4, Num.round); // 3
+     * Num.is.zero(0); // true
+     * Num.is.zero(5); // false
      * ```
      */
-    round: (n: number) => number;
+    zero: (n: number) => boolean;
     /**
-     * Rounds a number down to the nearest integer.
+     * Returns `true` when the number is a whole integer.
      *
      * @example
      * ```ts
-     * pipe(3.9, Num.floor); // 3
-     * pipe(-3.2, Num.floor); // -4
+     * Num.is.integer(5);    // true
+     * Num.is.integer(3.14); // false
      * ```
      */
-    floor: (n: number) => number;
+    integer: (n: number) => boolean;
     /**
-     * Rounds a number up to the nearest integer.
+     * Returns `true` when the number is a finite float (fractional number).
      *
      * @example
      * ```ts
-     * pipe(3.1, Num.ceil); // 4
-     * pipe(-3.9, Num.ceil); // -3
+     * Num.is.float(3.14); // true
+     * Num.is.float(5);    // false
      * ```
      */
-    ceil: (n: number) => number;
+    float: (n: number) => boolean;
     /**
-     * Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
-     * Data-last: `remainder(divisor)(a)` = `a % divisor`.
+     * Returns `true` when the number is finite (not `Infinity`, `-Infinity`, or `NaN`).
      *
      * @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]
+     * Num.is.finite(42);       // true
+     * Num.is.finite(Infinity); // false
      * ```
      */
-    remainder: (divisor: number) => (n: number) => Maybe<number>;
+    finite: (n: number) => boolean;
     /**
-     * Computes the sum of a list of numbers. Returns `0` if the list is empty.
+     * Returns `true` when the value is `NaN`.
      *
      * @example
      * ```ts
-     * Num.sum([1, 2, 3]); // 6
-     * Num.sum([]);        // 0
+     * Num.is.nan(NaN); // true
+     * Num.is.nan(42);  // false
      * ```
      */
-    sum: (ns: readonly number[]) => number;
+    nan: (n: number) => boolean;
     /**
-     * Computes the mean of a list of numbers. Returns `None` if the list is empty.
+     * Returns `true` when the number is an even integer.
      *
      * @example
      * ```ts
-     * Num.mean([1, 2, 3]); // Some(2)
-     * Num.mean([]);        // None
+     * Num.is.even(4);   // true
+     * Num.is.even(3);   // false
+     * Num.is.even(2.5); // false
      * ```
      */
-    mean: (ns: readonly number[]) => Maybe<number>;
+    even: (n: number) => boolean;
     /**
-     * Computes the minimum of a list of numbers. Returns `None` if the list is empty.
+     * Returns `true` when the number is an odd integer.
      *
      * @example
      * ```ts
-     * Num.min([5, 1, 3]); // Some(1)
-     * Num.min([]);        // None
+     * Num.is.odd(3);   // true
+     * Num.is.odd(4);   // false
+     * Num.is.odd(2.5); // false
      * ```
      */
-    min: (ns: readonly number[]) => Maybe<number>;
+    odd: (n: number) => boolean;
     /**
-     * Computes the maximum of a list of numbers. Returns `None` if the list is empty.
+     * Returns `true` when the number is strictly greater than zero.
      *
      * @example
      * ```ts
-     * Num.max([1, 5, 3]); // Some(5)
-     * Num.max([]);        // None
+     * Num.is.positive(5);  // true
+     * Num.is.positive(0);  // false
+     * Num.is.positive(-5); // false
      * ```
      */
-    max: (ns: readonly number[]) => Maybe<number>;
+    positive: (n: number) => boolean;
     /**
-     * Formats a number using `Intl.NumberFormat`. Returns `None` when `n` is `NaN` or non-finite.
-     * Data-last curried signature.
+     * Returns `true` when the number is strictly less than zero.
      *
      * @example
      * ```ts
-     * const formatCurrency = Num.format({ style: "currency", currency: "USD" }, "en-US");
-     * pipe(1234.5, formatCurrency); // Some("$1,234.50")
-     * pipe(NaN, formatCurrency);    // None
+     * Num.is.negative(-5); // true
+     * Num.is.negative(0);  // false
+     * Num.is.negative(5);  // false
      * ```
      */
-    format: (options?: Intl.NumberFormatOptions, locales?: string | string[]) => (n: number) => Maybe<string>;
+    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`,
+   * returns an empty array. When `step` does not land exactly on `to`, the last value
+   * is the largest reachable value that does not exceed `to`.
+   *
+   * @example
+   * ```ts
+   * Num.range(0, 5);       // [0, 1, 2, 3, 4, 5]
+   * Num.range(0, 10, 2);   // [0, 2, 4, 6, 8, 10]
+   * Num.range(0, 9, 2);    // [0, 2, 4, 6, 8]
+   * Num.range(5, 0);       // []
+   * Num.range(3, 3);       // [3]
+   * ```
+   */
+  range: (from: number, to: number, step?: number) => readonly number[];
+  /**
+   * Clamps a number between `min` and `max` (both inclusive).
+   *
+   * @example
+   * ```ts
+   * pipe(150, Num.clamp(0, 100)); // 100
+   * pipe(-5, Num.clamp(0, 100));  // 0
+   * pipe(42, Num.clamp(0, 100));  // 42
+   * ```
+   */
+  clamp: (min: number, max: number) => (n: number) => number;
+  /**
+   * Returns `true` when the number is between `min` and `max` (both inclusive).
+   *
+   * @example
+   * ```ts
+   * pipe(5, Num.between(1, 10));  // true
+   * pipe(0, Num.between(1, 10));  // false
+   * pipe(10, Num.between(1, 10)); // true
+   * ```
+   */
+  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`).
+   *
+   * @example
+   * ```ts
+   * pipe(5, Num.inRange(1, 10));  // true
+   * pipe(1, Num.inRange(1, 10));  // true
+   * pipe(10, Num.inRange(1, 10)); // false
+   * ```
+   */
+  inRange: (start: number, end: number) => (n: number) => boolean;
+  /**
+   * Parses a string as a number. Returns `None` when the result is `NaN`.
+   *
+   * @example
+   * ```ts
+   * Num.parse("42");   // Some(42)
+   * Num.parse("3.14"); // Some(3.14)
+   * Num.parse("abc");  // None
+   * Num.parse("");     // None
+   * ```
+   */
+  parse: (s: string) => Maybe<number>;
+  /**
+   * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
+   *
+   * @example
+   * ```ts
+   * pipe(5, Num.add(3));                   // 8
+   * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
+   * ```
+   */
+  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]
+   * ```
+   */
+  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]
+   * ```
+   */
+  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]
+   * ```
+   */
+  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
+   * ```
+   */
+  abs: (n: number) => number;
+  /**
+   * Negates a number (arithmetic negation).
+   *
+   * @example
+   * ```ts
+   * pipe(5, Num.negate);  // -5
+   * pipe(-5, Num.negate); // 5
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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]
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  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
+   * ```
+   */
+  format: (options?: Intl.NumberFormatOptions, locales?: string | string[]) => (n: number) => Maybe<string>;
 };
-
+//#endregion
+//#region src/Data/Rec.d.ts
 /**
  * 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>>>;
+export type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">, Readonly<Record<K, A>>>;
 /**
  * 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))`.
@@ -721,407 +1067,408 @@ type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">, Reado
  * ```
  */
 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>>;
+  (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: {
-        /**
-         * Creates a record from key-value pairs.
-         *
-         * @example
-         * ```ts
-         * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
-         * ```
-         */
-        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>;
-}
-
-/**
- * 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.
-         *
-         * @example
-         * ```ts
-         * pipe("", Str.is.empty);   // true
-         * pipe("hi", Str.is.empty); // false
-         * ```
-         */
-        empty: (s: string) => boolean;
-        /**
-         * Type guard to check if a string is non-empty.
-         */
-        nonEmpty: (s: string) => s is NonEmptyString;
-    };
-    /**
-     * Splits a string by a separator. Data-last: use in `pipe`.
-     *
-     * @example
-     * ```ts
-     * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
-     * ```
-     */
-    split: (separator: string | RegExp) => (s: string) => readonly string[];
-    /**
-     * Removes leading and trailing whitespace from a string.
-     *
-     * @example
-     * ```ts
-     * pipe("  hello  ", Str.trim); // "hello"
-     * ```
-     */
-    trim: (s: string) => string;
-    /**
-     * Returns `true` when the string contains the given substring.
-     *
-     * @example
-     * ```ts
-     * pipe("hello world", Str.includes("world")); // true
-     * pipe("hello world", Str.includes("xyz"));   // false
-     * ```
-     */
-    includes: (substring: string) => (s: string) => boolean;
-    /**
-     * Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
-     *
-     * @example
-     * ```ts
-     * pipe("foo foo foo", Str.replace("foo", "bar")); // "bar foo foo"
-     * pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
-     * ```
-     */
-    replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
-    /**
-     * Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
-     *
-     * @example
-     * ```ts
-     * pipe("foo foo foo", Str.replaceAll("foo", "bar")); // "bar bar bar"
-     * pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
-     * ```
-     */
-    replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+export declare const Rec: {
+  is: {
     /**
-     * Returns `true` when the string starts with the given prefix.
+     * Returns true if the record has no keys.
      *
      * @example
      * ```ts
-     * pipe("hello world", Str.startsWith("hello")); // true
-     * pipe("hello world", Str.startsWith("world")); // false
+     * Rec.is.empty({});       // true
+     * Rec.is.empty({ a: 1 }); // false
      * ```
      */
-    startsWith: (prefix: string) => (s: string) => boolean;
+    empty: <A>(data: Readonly<Record<string, A>>) => boolean;
     /**
-     * Returns `true` when the string ends with the given suffix.
+     * Type guard to check if a record is non-empty.
      *
      * @example
      * ```ts
-     * pipe("hello world", Str.endsWith("world")); // true
-     * pipe("hello world", Str.endsWith("hello")); // false
+     * Rec.is.nonEmpty({ a: 1 }); // true
+     * Rec.is.nonEmpty({});       // false
      * ```
      */
-    endsWith: (suffix: string) => (s: string) => boolean;
+    nonEmpty: <A, K extends string>(data: Readonly<Record<K, A>>) => data is NonEmptyRecord<A, K>;
+  };
+  from: {
     /**
-     * Converts a string to uppercase.
+     * Creates a record from key-value pairs.
      *
      * @example
      * ```ts
-     * pipe("hello", Str.toUpperCase); // "HELLO"
+     * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
      * ```
      */
-    toUpperCase: (s: string) => string;
-    /**
-     * Converts a string to lowercase.
-     *
-     * @example
-     * ```ts
-     * pipe("HELLO", Str.toLowerCase); // "hello"
-     * ```
-     */
-    toLowerCase: (s: string) => string;
-    /**
-     * Converts the first character of a string to uppercase.
-     *
-     * @example
-     * ```ts
-     * pipe("hello", Str.capitalize); // "Hello"
-     * ```
-     */
-    capitalize: (s: string) => string;
-    /**
-     * Splits a string into lines, normalising `\r\n` and `\r` line endings.
-     *
-     * @example
-     * ```ts
-     * Str.lines("one\ntwo\nthree"); // ["one", "two", "three"]
-     * Str.lines("a\r\nb");         // ["a", "b"]
-     * ```
-     */
-    lines: (s: string) => readonly string[];
-    /**
-     * Splits a string into words on any whitespace boundary, filtering out empty strings.
-     *
-     * @example
-     * ```ts
-     * Str.words("  hello   world  "); // ["hello", "world"]
-     * ```
-     */
-    words: (s: string) => readonly string[];
-    /**
-     * Returns `true` when the string is empty or contains only whitespace.
-     *
-     * @example
-     * ```ts
-     * pipe("   ", Str.isBlank); // true
-     * pipe("hi", Str.isBlank);  // false
-     * ```
-     */
-    isBlank: (s: string) => boolean;
-    /**
-     * Returns the length of the string.
-     *
-     * @example
-     * ```ts
-     * pipe("hello", Str.length); // 5
-     * pipe("", Str.length);      // 0
-     * ```
-     */
-    length: (s: string) => number;
-    /**
-     * Extracts a substring between two indices. Data-last: use in `pipe`.
-     *
-     * @example
-     * ```ts
-     * pipe("hello", Str.slice(1, 3)); // "el"
-     * pipe("hello", Str.slice(2));    // "llo"
-     * ```
-     */
-    slice: (start: number, end?: number) => (s: string) => string;
-    /**
-     * Pads the start of a string to a specified length. Data-last: use in `pipe`.
-     *
-     * @example
-     * ```ts
-     * pipe("5", Str.padStart(3, "0")); // "005"
-     * pipe("hi", Str.padStart(5));     // "   hi"
-     * ```
-     */
-    padStart: (maxLength: number, fillString?: string) => (s: string) => string;
+    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>;
+  };
+};
+export declare namespace Rec {
+  type NonEmpty<A, K extends string = string> = NonEmptyRecord<A, K>;
+}
+//#endregion
+//#region src/Data/Str.d.ts
+/**
+ * A branded type representing a string with at least one character.
+ */
+export type NonEmptyString = Brand<NonEmpty<"Str">, string>;
+export declare const Str: {
+  is: {
     /**
-     * Pads the end of a string to a specified length. Data-last: use in `pipe`.
+     * Returns `true` when the string is empty.
      *
      * @example
      * ```ts
-     * pipe("hi", Str.padEnd(5, "."));  // "hi..."
-     * pipe("hi", Str.padEnd(5));       // "hi   "
+     * pipe("", Str.is.empty);   // true
+     * pipe("hi", Str.is.empty); // false
      * ```
      */
-    padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
-    /**
-     * Safe number parsers that return `Maybe` instead of `NaN`.
-     */
-    parse: {
-        /**
-         * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
-         *
-         * @example
-         * ```ts
-         * Str.parse.int("42");   // Some(42)
-         * Str.parse.int("3.7");  // Some(3)
-         * Str.parse.int("abc");  // None
-         * ```
-         */
-        int: (s: string) => Maybe<number>;
-        /**
-         * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
-         *
-         * @example
-         * ```ts
-         * Str.parse.float("3.14"); // Some(3.14)
-         * Str.parse.float("42");   // Some(42)
-         * Str.parse.float("abc");  // None
-         * ```
-         */
-        float: (s: string) => Maybe<number>;
-    };
+    empty: (s: string) => boolean;
     /**
-     * Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
-     *
-     * @example
-     * ```ts
-     * Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
-     * Str.parseJson('invalid');  // Err(SyntaxError)
-     * ```
+     * Type guard to check if a string is non-empty.
      */
-    parseJson: (s: string) => Result<SyntaxError, unknown>;
+    nonEmpty: (s: string) => s is NonEmptyString;
+  };
+  /**
+   * Splits a string by a separator. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
+   * ```
+   */
+  split: (separator: string | RegExp) => (s: string) => readonly string[];
+  /**
+   * Removes leading and trailing whitespace from a string.
+   *
+   * @example
+   * ```ts
+   * pipe("  hello  ", Str.trim); // "hello"
+   * ```
+   */
+  trim: (s: string) => string;
+  /**
+   * Returns `true` when the string contains the given substring.
+   *
+   * @example
+   * ```ts
+   * pipe("hello world", Str.includes("world")); // true
+   * pipe("hello world", Str.includes("xyz"));   // false
+   * ```
+   */
+  includes: (substring: string) => (s: string) => boolean;
+  /**
+   * Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("foo foo foo", Str.replace("foo", "bar")); // "bar foo foo"
+   * pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
+   * ```
+   */
+  replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+  /**
+   * Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("foo foo foo", Str.replaceAll("foo", "bar")); // "bar bar bar"
+   * pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
+   * ```
+   */
+  replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+  /**
+   * Returns `true` when the string starts with the given prefix.
+   *
+   * @example
+   * ```ts
+   * pipe("hello world", Str.startsWith("hello")); // true
+   * pipe("hello world", Str.startsWith("world")); // false
+   * ```
+   */
+  startsWith: (prefix: string) => (s: string) => boolean;
+  /**
+   * Returns `true` when the string ends with the given suffix.
+   *
+   * @example
+   * ```ts
+   * pipe("hello world", Str.endsWith("world")); // true
+   * pipe("hello world", Str.endsWith("hello")); // false
+   * ```
+   */
+  endsWith: (suffix: string) => (s: string) => boolean;
+  /**
+   * Converts a string to uppercase.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.toUpperCase); // "HELLO"
+   * ```
+   */
+  toUpperCase: (s: string) => string;
+  /**
+   * Converts a string to lowercase.
+   *
+   * @example
+   * ```ts
+   * pipe("HELLO", Str.toLowerCase); // "hello"
+   * ```
+   */
+  toLowerCase: (s: string) => string;
+  /**
+   * Converts the first character of a string to uppercase.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.capitalize); // "Hello"
+   * ```
+   */
+  capitalize: (s: string) => string;
+  /**
+   * Splits a string into lines, normalising `\r\n` and `\r` line endings.
+   *
+   * @example
+   * ```ts
+   * Str.lines("one\ntwo\nthree"); // ["one", "two", "three"]
+   * Str.lines("a\r\nb");         // ["a", "b"]
+   * ```
+   */
+  lines: (s: string) => readonly string[];
+  /**
+   * Splits a string into words on any whitespace boundary, filtering out empty strings.
+   *
+   * @example
+   * ```ts
+   * Str.words("  hello   world  "); // ["hello", "world"]
+   * ```
+   */
+  words: (s: string) => readonly string[];
+  /**
+   * Returns `true` when the string is empty or contains only whitespace.
+   *
+   * @example
+   * ```ts
+   * pipe("   ", Str.isBlank); // true
+   * pipe("hi", Str.isBlank);  // false
+   * ```
+   */
+  isBlank: (s: string) => boolean;
+  /**
+   * Returns the length of the string.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.length); // 5
+   * pipe("", Str.length);      // 0
+   * ```
+   */
+  length: (s: string) => number;
+  /**
+   * Extracts a substring between two indices. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.slice(1, 3)); // "el"
+   * pipe("hello", Str.slice(2));    // "llo"
+   * ```
+   */
+  slice: (start: number, end?: number) => (s: string) => string;
+  /**
+   * Pads the start of a string to a specified length. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("5", Str.padStart(3, "0")); // "005"
+   * pipe("hi", Str.padStart(5));     // "   hi"
+   * ```
+   */
+  padStart: (maxLength: number, fillString?: string) => (s: string) => string;
+  /**
+   * Pads the end of a string to a specified length. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("hi", Str.padEnd(5, "."));  // "hi..."
+   * pipe("hi", Str.padEnd(5));       // "hi   "
+   * ```
+   */
+  padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
+  /**
+   * Safe number parsers that return `Maybe` instead of `NaN`.
+   */
+  parse: {
     /**
-     * Converts the first character of a string to lower case.
+     * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
      *
      * @example
      * ```ts
-     * Str.uncapitalize("Hello"); // "hello"
-     * Str.uncapitalize("");      // ""
+     * Str.parse.int("42");   // Some(42)
+     * Str.parse.int("3.7");  // Some(3)
+     * Str.parse.int("abc");  // None
      * ```
      */
-    uncapitalize: (s: string) => string;
+    int: (s: string) => Maybe<number>;
     /**
-     * Truncates a string to a maximum length, appending an optional suffix (default `"..."`).
-     * Data-last curried signature.
+     * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
      *
      * @example
      * ```ts
-     * pipe("Hello, world!", Str.truncate({ length: 8 })); // "Hello..."
-     * pipe("Hello", Str.truncate({ length: 10 }));        // "Hello"
-     * pipe("Hello, world!", Str.truncate({ length: 8, suffix: "…" })); // "Hello, w…"
+     * Str.parse.float("3.14"); // Some(3.14)
+     * Str.parse.float("42");   // Some(42)
+     * Str.parse.float("abc");  // None
      * ```
      */
-    truncate: (options: {
-        length: number;
-        suffix?: string;
-    }) => (s: string) => string;
-    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>;
-        };
+    float: (s: string) => Maybe<number>;
+  };
+  /**
+   * Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
+   *
+   * @example
+   * ```ts
+   * Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
+   * Str.parseJson('invalid');  // Err(SyntaxError)
+   * ```
+   */
+  parseJson: (s: string) => Result<SyntaxError, unknown>;
+  /**
+   * Converts the first character of a string to lower case.
+   *
+   * @example
+   * ```ts
+   * Str.uncapitalize("Hello"); // "hello"
+   * Str.uncapitalize("");      // ""
+   * ```
+   */
+  uncapitalize: (s: string) => string;
+  /**
+   * Truncates a string to a maximum length, appending an optional suffix (default `"..."`).
+   * Data-last curried signature.
+   *
+   * @example
+   * ```ts
+   * pipe("Hello, world!", Str.truncate({ length: 8 })); // "Hello..."
+   * pipe("Hello", Str.truncate({ length: 10 }));        // "Hello"
+   * pipe("Hello, world!", Str.truncate({ length: 8, suffix: "…" })); // "Hello, w…"
+   * ```
+   */
+  truncate: (options: {
+    length: number;
+    suffix?: string;
+  }) => (s: string) => string;
+  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;
+export declare namespace Str {
+  /**
+   * A branded type representing a string with at least one character.
+   */
+  type NonEmpty = NonEmptyString;
 }
-
+//#endregion
+//#region src/Data/Uniq.d.ts
 /**
  * A branded type representing a unique collection with at least one element.
  */
-type NonEmptySet<A> = Brand<NonEmpty<"Uniq">, ReadonlySet<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>;
+export type NonEmptySet<A> = Brand<NonEmpty<"Uniq">, ReadonlySet<A>>;
+export 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: {
-        Array: <A>(arr: readonly A[]) => ReadonlySet<A>;
+      Set: <A>(s: ReadonlySet<A>) => Maybe<NonEmptySet<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;
+    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: 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>;
-        };
+      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>;
+export declare namespace Uniq {
+  /**
+   * A branded type representing a unique collection with at least one element.
+   */
+  type NonEmpty<A> = NonEmptySet<A>;
 }
-
-export { Arr, BigNum, Dict, Json, type NonEmptyMap, type NonEmptyRecord, type NonEmptySet, type NonEmptyString, Num, Rec, Str, Uniq };
+//#endregion