@nlozgachev/pipelined 0.62.0 → 0.63.0

package/dist/data.mjs

@@ -1,264 +1,1185 @@
 // src/Core/Deferred.ts
-var Deferred;
-((Deferred2) => {
-  let from;
-  ((from2) => {
-    from2.Promise = (p) => (
-      // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
-      { then: ((f) => p.then(f)) }
-    );
-  })(from = Deferred2.from || (Deferred2.from = {}));
-  let to;
-  ((to2) => {
-    to2.Promise = (d) => new globalThis.Promise((resolve) => d.then(resolve));
-  })(to = Deferred2.to || (Deferred2.to = {}));
-  Deferred2.all = (deferreds) => from.Promise(globalThis.Promise.all(deferreds.map((d) => to.Promise(d))));
-  Deferred2.race = (deferreds) => from.Promise(globalThis.Promise.race(deferreds.map((d) => to.Promise(d))));
-})(Deferred || (Deferred = {}));
+var fromPromise = (p) => ({ then: ((f) => p.then(f)) });
+var toPromise = (d) => new globalThis.Promise((resolve) => d.then(resolve));
+var Deferred = {
+  // --- from ---
+  from: {
+    /**
+     * Wraps a `Promise` or `Deferred` into a `Deferred`, structurally excluding rejection handlers,
+     * `.catch()`, `.finally()`, and chainable `.then()`.
+     *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `Task.Result.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.from.Promise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    Promise: fromPromise
+  },
+  // --- to ---
+  to: {
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.to.Promise(Deferred.from.Promise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    Promise: toPromise
+  },
+  /**
+   * Combines an array or tuple of `Deferred` values into a single `Deferred` of a tuple.
+   * Resolves when all input `Deferred`s resolve.
+   *
+   * @example
+   * ```ts
+   * const [a, b] = await Deferred.all([d1, d2]);
+   * ```
+   */
+  all: (deferreds) => fromPromise(globalThis.Promise.all(deferreds.map((d) => toPromise(d)))),
+  /**
+   * Races multiple `Deferred` values and resolves with the first one to settle.
+   *
+   * @example
+   * ```ts
+   * const winner = await Deferred.race([d1, d2]);
+   * ```
+   */
+  race: (deferreds) => fromPromise(globalThis.Promise.race(deferreds.map((d) => toPromise(d))))
+};
 
 // src/Core/Maybe.ts
 var _none = { kind: "None" };
-var Maybe;
-((Maybe2) => {
-  let make;
-  ((make2) => {
-    make2.some = (value) => ({ kind: "Some", value });
-    make2.none = () => _none;
-  })(make = Maybe2.make || (Maybe2.make = {}));
-  let is;
-  ((is2) => {
-    is2.some = (data) => data.kind === "Some";
-    is2.none = (data) => data.kind === "None";
-  })(is = Maybe2.is || (Maybe2.is = {}));
-  let to;
-  ((to2) => {
-    to2.nullable = (data) => is.some(data) ? data.value : null;
-    to2.undefined = (data) => is.some(data) ? data.value : globalThis.undefined;
-    to2.Result = (onNone) => (data) => is.some(data) ? Result.make.ok(data.value) : Result.make.err(onNone());
-  })(to = Maybe2.to || (Maybe2.to = {}));
-  let from;
-  ((from2) => {
-    from2.nullable = (value) => value === null || value === void 0 ? make.none() : make.some(value);
-    from2.Predicate = (pred) => (a) => pred(a) ? make.some(a) : make.none();
-    from2.Result = (data) => Result.is.ok(data) ? make.some(data.value) : make.none();
-  })(from = Maybe2.from || (Maybe2.from = {}));
-  Maybe2.map = (f) => (data) => is.some(data) ? make.some(f(data.value)) : data;
-  Maybe2.chain = (f) => (data) => is.some(data) ? f(data.value) : data;
-  Maybe2.fold = (onNone, onSome) => (data) => is.some(data) ? onSome(data.value) : onNone();
-  Maybe2.match = (cases) => (data) => is.some(data) ? cases.some(data.value) : cases.none();
-  Maybe2.getOrElse = (defaultValue) => (data) => is.some(data) ? data.value : defaultValue();
-  Maybe2.tap = (f) => (data) => {
-    if (is.some(data)) {
+var makeSome = (value) => ({ kind: "Some", value });
+var makeNone = () => _none;
+var isSome = (data) => data.kind === "Some";
+var isNone = (data) => data.kind === "None";
+var Maybe = {
+  make: {
+    /**
+     * Creates a Some containing the given value.
+     *
+     * @example
+     * ```ts
+     * Maybe.make.some(42); // Some(42)
+     * ```
+     */
+    some: makeSome,
+    /**
+     * Creates a None (empty Maybe).
+     *
+     * @example
+     * ```ts
+     * Maybe.make.none(); // None
+     * ```
+     */
+    none: makeNone
+  },
+  is: {
+    /**
+     * Type guard that checks if a Maybe is Some.
+     *
+     * @example
+     * ```ts
+     * const value = Maybe.make.some(42);
+     * if (Maybe.is.some(value)) {
+     *   console.log(value.value); // 42
+     * }
+     * ```
+     */
+    some: isSome,
+    /**
+     * Type guard that checks if a Maybe is None.
+     *
+     * @example
+     * ```ts
+     * const value = Maybe.make.none();
+     * if (Maybe.is.none(value)) {
+     *   console.log("No value present");
+     * }
+     * ```
+     */
+    none: isNone
+  },
+  // --- to ---
+  to: {
+    /**
+     * Extracts the value from a Maybe, returning null if None.
+     *
+     * @example
+     * ```ts
+     * Maybe.to.nullable(Maybe.make.some(42)); // 42
+     * Maybe.to.nullable(Maybe.make.none());   // null
+     * ```
+     */
+    nullable: (data) => isSome(data) ? data.value : null,
+    /**
+     * Extracts the value from a Maybe, returning undefined if None.
+     *
+     * @example
+     * ```ts
+     * Maybe.to.undefined(Maybe.make.some(42)); // 42
+     * Maybe.to.undefined(Maybe.make.none());   // undefined
+     * ```
+     */
+    undefined: (data) => isSome(data) ? data.value : globalThis.undefined,
+    /**
+     * Converts a Maybe to a Result.
+     * Some becomes Ok, None becomes Err with the provided error.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Maybe.make.some(42),
+     *   Maybe.to.Result(() => "Value was missing")
+     * ); // Ok(42)
+     *
+     * pipe(
+     *   Maybe.make.none(),
+     *   Maybe.to.Result(() => "Value was missing")
+     * ); // Err("Value was missing")
+     * ```
+     */
+    Result: (onNone) => (data) => isSome(data) ? Result.make.ok(data.value) : Result.make.err(onNone())
+  },
+  // --- from ---
+  from: {
+    /**
+     * Creates a Maybe from a nullable value.
+     * Returns None if the value is null or undefined, Some otherwise.
+     *
+     * @example
+     * ```ts
+     * Maybe.from.nullable(null); // None
+     * Maybe.from.nullable(42); // Some(42)
+     * ```
+     */
+    nullable: (value) => value === null || value === void 0 ? makeNone() : makeSome(value),
+    /**
+     * Creates a Maybe from a predicate applied to a value.
+     * Returns Some if the predicate passes, None otherwise.
+     *
+     * @example
+     * ```ts
+     * Maybe.from.Predicate((n: number) => n >= 18)(21); // Some(21)
+     * Maybe.from.Predicate((n: number) => n >= 18)(15); // None
+     *
+     * pipe("hello", Maybe.from.Predicate((s: string) => s.length > 0)); // Some("hello")
+     * pipe("", Maybe.from.Predicate((s: string) => s.length > 0));      // None
+     * ```
+     */
+    Predicate: (pred) => (a) => pred(a) ? makeSome(a) : makeNone(),
+    /**
+     * Creates a Maybe from a Result.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Maybe.from.Result(Result.make.ok(42)); // Some(42)
+     * Maybe.from.Result(Result.make.err("oops")); // None
+     * ```
+     */
+    Result: (data) => Result.is.ok(data) ? makeSome(data.value) : makeNone()
+  },
+  /**
+   * Transforms the value inside a Maybe if it exists.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.some(5), Maybe.map(n => n * 2)); // Some(10)
+   * pipe(Maybe.make.none(), Maybe.map(n => n * 2)); // None
+   * ```
+   */
+  map: (f) => (data) => isSome(data) ? makeSome(f(data.value)) : data,
+  /**
+   * Chains Maybe computations. If the first is Some, passes the value to f.
+   * If the first is None, propagates None.
+   *
+   * @example
+   * ```ts
+   * const parseNumber = (s: string): Maybe<number> => {
+   *   const n = parseInt(s, 10);
+   *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
+   * };
+   *
+   * pipe(Maybe.make.some("42"), Maybe.chain(parseNumber)); // Some(42)
+   * pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
+   * ```
+   */
+  chain: (f) => (data) => isSome(data) ? f(data.value) : data,
+  /**
+   * Extracts the value from a Maybe by providing handlers for both cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.some(5),
+   *   Maybe.fold(
+   *     () => "No value",
+   *     n => `Value: ${n}`
+   *   )
+   * ); // "Value: 5"
+   * ```
+   */
+  fold: (onNone, onSome) => (data) => isSome(data) ? onSome(data.value) : onNone(),
+  /**
+   * Pattern matches on a Maybe, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   optionUser,
+   *   Maybe.match({
+   *     some: user => `Hello, ${user.name}`,
+   *     none: () => "Hello, stranger"
+   *   })
+   * );
+   * ```
+   */
+  match: (cases) => (data) => isSome(data) ? cases.some(data.value) : cases.none(),
+  /**
+   * Returns the value inside a Maybe, or a default value if None.
+   * The default is a thunk `() => B` — evaluated only when the Maybe is None.
+   * The default can be a different type, widening the result to `A | B`.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.some(5), Maybe.getOrElse(() => 0)); // 5
+   * pipe(Maybe.make.none(), Maybe.getOrElse(() => 0)); // 0
+   * pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
+   * ```
+   */
+  getOrElse: (defaultValue) => (data) => isSome(data) ? data.value : defaultValue(),
+  /**
+   * Executes a side effect on the value without changing the Maybe.
+   * Useful for logging or debugging.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.some(5),
+   *   Maybe.tap(n => console.log("Value:", n)),
+   *   Maybe.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: (f) => (data) => {
+    if (isSome(data)) {
       f(data.value);
     }
     return data;
-  };
-  Maybe2.filter = (predicate) => (data) => is.some(data) ? predicate(data.value) ? data : make.none() : data;
-  Maybe2.recover = (fallback) => (data) => is.some(data) ? data : fallback();
-  Maybe2.ap = (arg) => (data) => is.some(data) && is.some(arg) ? make.some(data.value(arg.value)) : make.none();
-  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
-  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
-    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
-  )(data);
-  Maybe2.struct = (fields) => {
+  },
+  /**
+   * Filters a Maybe based on a predicate.
+   * Returns None if the predicate returns false or if the Maybe is already None.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
+   * pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
+   * ```
+   */
+  filter: (predicate) => (data) => isSome(data) ? predicate(data.value) ? data : makeNone() : data,
+  /**
+   * Recovers from a None by providing a fallback Maybe.
+   * The fallback can produce a different type, widening the result to `Maybe<A | B>`.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.none(), Maybe.recover(() => Maybe.make.some(42))); // Some(42)
+   * pipe(Maybe.make.some(10), Maybe.recover(() => Maybe.make.some(42))); // Some(10)
+   * ```
+   */
+  recover: (fallback) => (data) => isSome(data) ? data : fallback(),
+  /**
+   * Applies a function wrapped in a Maybe to a value wrapped in a Maybe.
+   *
+   * @example
+   * ```ts
+   * const add = (a: number) => (b: number) => a + b;
+   * pipe(
+   *   Maybe.make.some(add),
+   *   Maybe.ap(Maybe.make.some(5)),
+   *   Maybe.ap(Maybe.make.some(3))
+   * ); // Some(8)
+   * ```
+   */
+  ap: (arg) => (data) => isSome(data) && isSome(arg) ? makeSome(data.value(arg.value)) : makeNone(),
+  /**
+   * Converts a Maybe value into an object containing a single property.
+   * Initiates the pipeline accumulator record.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
+   * ```
+   */
+  bindTo: (key) => (data) => isSome(data) ? makeSome({ [key]: data.value }) : data,
+  /**
+   * Evaluates a new Maybe using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.some({ a: 1 }),
+   *   Maybe.bind("b", ({ a }) => Maybe.make.some(a + 1))
+   * ); // Some({ a: 1, b: 2 })
+   * ```
+   */
+  bind: (key, f) => (data) => {
+    if (!isSome(data)) {
+      return data;
+    }
+    const mb = f(data.value);
+    return isSome(mb) ? makeSome({ ...data.value, [key]: mb.value }) : mb;
+  },
+  /**
+   * Combines a record of Maybes into a single Maybe of a record.
+   * Evaluates fields in key order and short-circuits on the first None.
+   *
+   * @example
+   * ```ts
+   * Maybe.struct({
+   *   name: Maybe.make.some("Alice"),
+   *   age: Maybe.make.some(30)
+   * }); // Some({ name: "Alice", age: 30 })
+   * ```
+   */
+  struct: (fields) => {
     const result = {};
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const res = fields[key];
-        if (is.none(res)) {
+        if (isNone(res)) {
           return res;
         }
         result[key] = res.value;
       }
     }
-    return make.some(result);
-  };
-  Maybe2.transposeResult = (data) => is.none(data) ? Result.make.ok(make.none()) : Result.is.ok(data.value) ? Result.make.ok(make.some(data.value.value)) : Result.make.err(data.value.error);
-})(Maybe || (Maybe = {}));
+    return makeSome(result);
+  },
+  /**
+   * Swaps the outer `Maybe` and inner `Result` context.
+   * `Some(Ok(a))` becomes `Ok(Some(a))`, `Some(Err(e))` becomes `Err(e)`, and `None` becomes `Ok(None)`.
+   *
+   * @example
+   * ```ts
+   * Maybe.transposeResult(Maybe.make.some(Result.make.ok(42)));  // Ok(Some(42))
+   * Maybe.transposeResult(Maybe.make.some(Result.make.err("e"))); // Err("e")
+   * Maybe.transposeResult(Maybe.make.none());                     // Ok(None)
+   * ```
+   */
+  transposeResult: (data) => isNone(data) ? Result.make.ok(makeNone()) : Result.is.ok(data.value) ? Result.make.ok(makeSome(data.value.value)) : Result.make.err(data.value.error)
+};
 
 // src/Core/Result.ts
-var Result;
-((Result2) => {
-  let make;
-  ((make2) => {
-    make2.ok = (value) => ({ kind: "Ok", value });
-    make2.err = (e) => ({ kind: "Err", error: e });
-  })(make = Result2.make || (Result2.make = {}));
-  let is;
-  ((is2) => {
-    is2.ok = (data) => data.kind === "Ok";
-    is2.err = (data) => data.kind === "Err";
-  })(is = Result2.is || (Result2.is = {}));
-  Result2.tryCatch = (f, options) => {
+var makeOk = (value) => ({ kind: "Ok", value });
+var makeErr = (e) => ({ kind: "Err", error: e });
+var isOk = (data) => data.kind === "Ok";
+var isErr = (data) => data.kind === "Err";
+var Result = {
+  make: {
+    /**
+     * Creates a successful Result with the given value.
+     *
+     * @example
+     * ```ts
+     * Result.make.ok(42); // Ok(42)
+     * ```
+     */
+    ok: makeOk,
+    /**
+     * Creates a failed Result with the given error.
+     *
+     * @example
+     * ```ts
+     * Result.make.err("Error message"); // Err("Error message")
+     * ```
+     */
+    err: makeErr
+  },
+  is: {
+    /**
+     * Type guard that checks if a Result is Ok.
+     *
+     * @example
+     * ```ts
+     * const res = Result.make.ok(42);
+     * if (Result.is.ok(res)) {
+     *   console.log(res.value); // 42
+     * }
+     * ```
+     */
+    ok: isOk,
+    /**
+     * Type guard that checks if a Result is Err.
+     *
+     * @example
+     * ```ts
+     * const res = Result.make.err("failed");
+     * if (Result.is.err(res)) {
+     *   console.log(res.error); // "failed"
+     * }
+     * ```
+     */
+    err: isErr
+  },
+  /**
+   * Creates a Result from a synchronous thunk that may throw.
+   * Catches any errors and transforms them using the `onError` function.
+   *
+   * @example
+   * ```ts
+   * const result = Result.tryCatch(
+   *   () => JSON.parse(rawString),
+   *   { onError: (e) => `Parse error: ${e}` }
+   * );
+   * ```
+   */
+  tryCatch: (f, options) => {
     try {
-      return make.ok(f());
+      return makeOk(f());
     } catch (error) {
-      return make.err(options.onError(error));
-    }
-  };
-  Result2.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
-  Result2.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
-  Result2.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
-  Result2.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
-  Result2.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
-  Result2.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
-  Result2.tap = (f) => (data) => {
-    if (is.ok(data)) {
+      return makeErr(options.onError(error));
+    }
+  },
+  /**
+   * Transforms the success value inside a Result.
+   *
+   * @example
+   * ```ts
+   * pipe(Result.make.ok(5), Result.map(n => n * 2)); // Ok(10)
+   * pipe(Result.make.err("error"), Result.map(n => n * 2)); // Err("error")
+   * ```
+   */
+  map: (f) => (data) => isOk(data) ? makeOk(f(data.value)) : data,
+  /**
+   * Transforms the error value inside a Result.
+   *
+   * @example
+   * ```ts
+   * pipe(Result.make.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+   * ```
+   */
+  mapError: (f) => (data) => isErr(data) ? makeErr(f(data.error)) : data,
+  /**
+   * Chains Result computations. If the first is Ok, passes the value to f.
+   * If the first is Err, propagates the error.
+   *
+   * @example
+   * ```ts
+   * const validatePositive = (n: number): Result<string, number> =>
+   *   n > 0 ? Result.make.ok(n) : Result.make.err("Must be positive");
+   *
+   * pipe(Result.make.ok(5), Result.chain(validatePositive)); // Ok(5)
+   * pipe(Result.make.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
+   * ```
+   */
+  chain: (f) => (data) => isOk(data) ? f(data.value) : data,
+  /**
+   * Extracts the value from a Result by providing handlers for both cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(5),
+   *   Result.fold(
+   *     e => `Error: ${e}`,
+   *     n => `Value: ${n}`
+   *   )
+   * ); // "Value: 5"
+   * ```
+   */
+  fold: (onErr, onOk) => (data) => isOk(data) ? onOk(data.value) : onErr(data.error),
+  /**
+   * Pattern matches on a Result, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   result,
+   *   Result.match({
+   *     ok: value => `Got ${value}`,
+   *     err: error => `Failed: ${error}`
+   *   })
+   * );
+   * ```
+   */
+  match: (cases) => (data) => isOk(data) ? cases.ok(data.value) : cases.err(data.error),
+  /**
+   * Returns the success value or a default value if the Result is an error.
+   * The default is a thunk `() => B` — evaluated only when the Result is Err.
+   * The default can be a different type, widening the result to `A | B`.
+   *
+   * @example
+   * ```ts
+   * pipe(Result.make.ok(5), Result.getOrElse(() => 0)); // 5
+   * pipe(Result.make.err("error"), Result.getOrElse(() => 0)); // 0
+   * pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
+   * ```
+   */
+  getOrElse: (defaultValue) => (data) => isOk(data) ? data.value : defaultValue(),
+  /**
+   * Executes a side effect on the success value without changing the Result.
+   * Useful for logging or debugging.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(5),
+   *   Result.tap(n => console.log("Value:", n)),
+   *   Result.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: (f) => (data) => {
+    if (isOk(data)) {
       f(data.value);
     }
     return data;
-  };
-  Result2.tapError = (f) => (data) => {
-    if (is.err(data)) {
+  },
+  /**
+   * Executes a side effect on the error value without changing the Result.
+   * Useful for logging or reporting errors.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.err("not found"),
+   *   Result.tapError(e => console.error("validation failed:", e)),
+   *   Result.chain(save),
+   * )
+   * ```
+   */
+  tapError: (f) => (data) => {
+    if (isErr(data)) {
       f(data.error);
     }
     return data;
-  };
-  let from;
-  ((from2) => {
-    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.ok(a) : make.err(onFalse(a));
-    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.err(onNull()) : make.ok(value);
-    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.err(onNone()) : make.ok(maybe.value);
-    from2.Validation = (combineErrors) => (val) => Validation.is.passed(val) ? make.ok(val.value) : make.err(combineErrors(val.errors));
-  })(from = Result2.from || (Result2.from = {}));
-  Result2.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (isBlocked, fallback) => (data) => is.err(data) && !isBlocked(data.error) ? fallback() : data;
-  let to;
-  ((to2) => {
-    to2.Maybe = (data) => is.ok(data) ? Maybe.make.some(data.value) : Maybe.make.none();
-    to2.Validation = (data) => Validation.from.Result(data);
-  })(to = Result2.to || (Result2.to = {}));
-  Result2.transposeMaybe = (data) => is.err(data) ? Maybe.make.some(data) : Maybe.is.some(data.value) ? Maybe.make.some(make.ok(data.value.value)) : Maybe.make.none();
-  Result2.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
-  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
-  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
-    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
-  )(data);
-  Result2.struct = (fields) => {
+  },
+  // --- from ---
+  from: {
+    /**
+     * Creates a Result from a predicate applied to a value.
+     * Returns Ok if the predicate passes, Err from onFalse otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(5, Result.from.Predicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
+     * pipe(-1, Result.from.Predicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
+     * pipe("", Result.from.Predicate(s => s.length > 0, () => "empty string")); // Err("empty string")
+     * ```
+     */
+    Predicate: (pred, onFalse) => (a) => pred(a) ? makeOk(a) : makeErr(onFalse(a)),
+    /**
+     * Creates a Result from a nullable value.
+     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Result.from.nullable(() => "is null")); // Err("is null")
+     * pipe(42, Result.from.nullable(() => "is null"));   // Ok(42)
+     * ```
+     */
+    nullable: (onNull) => (value) => value === null || value === void 0 ? makeErr(onNull()) : makeOk(value),
+    /**
+     * Creates a Result from a Maybe.
+     * Some becomes Ok, None becomes error from onNone.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.make.none(), Result.from.Maybe(() => "is none")); // Err("is none")
+     * pipe(Maybe.make.some(42), Result.from.Maybe(() => "is none")); // Ok(42)
+     * ```
+     */
+    Maybe: (onNone) => (maybe) => Maybe.is.none(maybe) ? makeErr(onNone()) : makeOk(maybe.value),
+    /**
+     * Converts a `Validation` to a `Result`, combining accumulated errors using `combineErrors`.
+     * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
+     *
+     * @example
+     * ```ts
+     * Result.from.Validation((errors) => errors.join(", "))(Validation.make.failed("error1")); // Err("error1")
+     * ```
+     */
+    Validation: (combineErrors) => (val) => Validation.is.passed(val) ? makeOk(val.value) : makeErr(combineErrors(val.errors))
+  },
+  /**
+   * Recovers from an error by providing a fallback Result.
+   * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+   */
+  recover: (fallback) => (data) => isOk(data) ? data : fallback(data.error),
+  /**
+   * Recovers from an error unless the predicate `isBlocked` returns true for that error.
+   * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.err(new Error("not found")),
+   *   Result.recoverUnless(e => e.message === "fatal", () => Result.make.ok(0))
+   * ); // Ok(0)
+   * ```
+   */
+  recoverUnless: (isBlocked, fallback) => (data) => isErr(data) && !isBlocked(data.error) ? fallback() : data,
+  // --- to ---
+  to: {
+    /**
+     * Converts a Result to a Maybe.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Result.to.Maybe(Result.make.ok(42)); // Some(42)
+     * Result.to.Maybe(Result.make.err("oops")); // None
+     * ```
+     */
+    Maybe: (data) => isOk(data) ? Maybe.make.some(data.value) : Maybe.make.none(),
+    /**
+     * Converts a `Result` to a `Validation`. `Ok(a)` becomes `Passed(a)`; `Err(e)` becomes `Failed([e])`.
+     *
+     * @example
+     * ```ts
+     * Result.to.Validation(Result.make.ok(42));     // Passed(42)
+     * Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])
+     * ```
+     */
+    Validation: (data) => Validation.from.Result(data)
+  },
+  /**
+   * Swaps the outer `Result` and inner `Maybe` context.
+   * `Ok(Some(a))` becomes `Some(Ok(a))`, `Ok(None)` becomes `None`, and `Err(e)` becomes `Some(Err(e))`.
+   *
+   * @example
+   * ```ts
+   * Result.transposeMaybe(Result.make.ok(Maybe.make.some(42))); // Some(Ok(42))
+   * Result.transposeMaybe(Result.make.ok(Maybe.make.none()));   // None
+   * Result.transposeMaybe(Result.make.err("error"));           // Some(Err("error"))
+   * ```
+   */
+  transposeMaybe: (data) => isErr(data) ? Maybe.make.some(data) : Maybe.is.some(data.value) ? Maybe.make.some(makeOk(data.value.value)) : Maybe.make.none(),
+  /**
+   * Applies a function wrapped in a Result to a value wrapped in a Result.
+   *
+   * @example
+   * ```ts
+   * const add = (a: number) => (b: number) => a + b;
+   * pipe(
+   *   Result.make.ok(add),
+   *   Result.ap(Result.make.ok(5)),
+   *   Result.ap(Result.make.ok(3))
+   * ); // Ok(8)
+   * ```
+   */
+  ap: (arg) => (data) => isOk(data) && isOk(arg) ? makeOk(data.value(arg.value)) : isErr(data) ? data : arg,
+  /**
+   * Converts a Result value into an object containing a single property.
+   * Initiates the pipeline accumulator record.
+   *
+   * @example
+   * ```ts
+   * pipe(Result.make.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
+   * ```
+   */
+  bindTo: (key) => (data) => isOk(data) ? makeOk({ [key]: data.value }) : data,
+  /**
+   * Evaluates a new Result using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok({ a: 1 }),
+   *   Result.bind("b", ({ a }) => Result.make.ok(a + 1))
+   * ); // Ok({ a: 1, b: 2 })
+   * ```
+   */
+  bind: (key, f) => (data) => {
+    if (!isOk(data)) {
+      return data;
+    }
+    const res = f(data.value);
+    return isOk(res) ? makeOk({ ...data.value, [key]: res.value }) : res;
+  },
+  /**
+   * Combines a record of Results into a single Result of a record.
+   * Evaluates fields in key order and short-circuits on the first failure.
+   *
+   * @example
+   * ```ts
+   * Result.struct({
+   *   name: Result.make.ok("Alice"),
+   *   age: Result.make.ok(30)
+   * }); // Ok({ name: "Alice", age: 30 })
+   * ```
+   */
+  struct: (fields) => {
     const result = {};
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const res = fields[key];
-        if (is.err(res)) {
+        if (isErr(res)) {
           return res;
         }
         result[key] = res.value;
       }
     }
-    return make.ok(result);
-  };
-  Result2.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
-  Result2.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
-})(Result || (Result = {}));
+    return makeOk(result);
+  },
+  /**
+   * Narrows an `Ok` value with a predicate, converting to `Err(onFail(a))` if the predicate returns false.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(15),
+   *   Result.ensure((n) => n >= 18, (n) => `Age ${n} is below 18`)
+   * ); // Err("Age 15 is below 18")
+   * ```
+   */
+  ensure: (predicate, onFail) => (data) => isErr(data) ? data : predicate(data.value) ? data : makeErr(onFail(data.value)),
+  /**
+   * Transforms both branches of a Result simultaneously.
+   * Applies `onErr` to `Err` values and `onOk` to `Ok` values.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(5),
+   *   Result.bimap(
+   *     (e) => `Error: ${e}`,
+   *     (n) => n * 2
+   *   )
+   * ); // Ok(10)
+   * ```
+   */
+  bimap: (onErr, onOk) => (data) => isOk(data) ? makeOk(onOk(data.value)) : makeErr(onErr(data.error))
+};
 
 // src/internal/InternalTypes.ts
 var isNonEmptyArr = (list) => list.length > 0;
 
 // src/Core/Validation.ts
-var Validation;
-((Validation2) => {
-  let make;
-  ((make2) => {
-    make2.passed = (value) => ({ kind: "Passed", value });
-    make2.failed = (error) => ({ kind: "Failed", errors: [error] });
-    make2.failedAll = (errors) => ({ kind: "Failed", errors });
-  })(make = Validation2.make || (Validation2.make = {}));
-  let is;
-  ((is2) => {
-    is2.passed = (data) => data.kind === "Passed";
-    is2.failed = (data) => data.kind === "Failed";
-  })(is = Validation2.is || (Validation2.is = {}));
-  Validation2.tryCatch = (f, options) => {
+var makePassed = (value) => ({ kind: "Passed", value });
+var makeFailed = (error) => ({ kind: "Failed", errors: [error] });
+var makeFailedAll = (errors) => ({ kind: "Failed", errors });
+var isPassed = (data) => data.kind === "Passed";
+var isFailed = (data) => data.kind === "Failed";
+function toResult(arg) {
+  if (typeof arg === "function") {
+    const combine = arg;
+    return (val) => isPassed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
+  }
+  return isPassed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
+}
+var Validation = {
+  make: {
+    /**
+     * Wraps a value in a passed Validation.
+     *
+     * @example
+     * ```ts
+     * Validation.make.passed(42); // Passed(42)
+     * ```
+     */
+    passed: makePassed,
+    /**
+     * Creates a failed Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.make.failed("Invalid input");
+     * ```
+     */
+    failed: makeFailed,
+    /**
+     * Creates a failed Validation from multiple errors.
+     *
+     * @example
+     * ```ts
+     * Validation.make.failedAll(["Invalid input"]);
+     * ```
+     */
+    failedAll: makeFailedAll
+  },
+  is: {
+    /**
+     * Type guard that checks if a Validation is passed.
+     *
+     * @example
+     * ```ts
+     * const v = Validation.make.passed(42);
+     * if (Validation.is.passed(v)) {
+     *   console.log(v.value); // 42
+     * }
+     * ```
+     */
+    passed: isPassed,
+    /**
+     * Type guard that checks if a Validation is failed.
+     *
+     * @example
+     * ```ts
+     * const v = Validation.make.failed("invalid");
+     * if (Validation.is.failed(v)) {
+     *   console.log(v.errors); // ["invalid"]
+     * }
+     * ```
+     */
+    failed: isFailed
+  },
+  /**
+   * Creates a Validation from a synchronous thunk that may throw.
+   * Catches any errors and transforms them using the `onError` function into a Failed validation.
+   *
+   * @example
+   * ```ts
+   * const result = Validation.tryCatch(
+   *   () => JSON.parse(rawString),
+   *   { onError: (e) => `Parse error: ${e}` }
+   * );
+   * ```
+   */
+  tryCatch: (f, options) => {
     try {
-      return make.passed(f());
+      return makePassed(f());
     } catch (error) {
-      return make.failed(options.onError(error));
+      return makeFailed(options.onError(error));
     }
-  };
-  let from;
-  ((from2) => {
-    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.passed(a) : make.failed(onFalse(a));
-    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.failed(onNull()) : make.passed(value);
-    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.failed(onNone()) : make.passed(maybe.value);
-    from2.Result = (data) => data.kind === "Ok" ? make.passed(data.value) : make.failed(data.error);
-  })(from = Validation2.from || (Validation2.from = {}));
-  Validation2.map = (f) => (data) => is.passed(data) ? make.passed(f(data.value)) : data;
-  Validation2.mapError = (f) => (data) => is.failed(data) ? make.failedAll(data.errors.map(f)) : data;
-  Validation2.ap = (arg) => (data) => {
-    if (is.passed(data)) {
-      return is.passed(arg) ? make.passed(data.value(arg.value)) : make.failedAll(arg.errors);
-    }
-    return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll([...data.errors, ...arg.errors]);
-  };
-  Validation2.apCustom = (concat) => (arg) => (data) => {
-    if (is.passed(data)) {
-      return is.passed(arg) ? make.passed(data.value(arg.value)) : make.failedAll(arg.errors);
-    }
-    return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll(concat(data.errors, arg.errors));
-  };
-  Validation2.fold = (onFailed, onPassed) => (data) => is.passed(data) ? onPassed(data.value) : onFailed(data.errors);
-  Validation2.match = (cases) => (data) => is.passed(data) ? cases.passed(data.value) : cases.failed(data.errors);
-  Validation2.getOrElse = (defaultValue) => (data) => is.passed(data) ? data.value : defaultValue();
-  Validation2.tap = (f) => (data) => {
-    if (is.passed(data)) {
+  },
+  // --- from ---
+  from: {
+    /**
+     * Creates a Validation from a predicate applied to a value.
+     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
+     *
+     * @example
+     * ```ts
+     * const validateName = Validation.from.Predicate(
+     *   (s: string) => s.length > 0,
+     *   () => "Name is required"
+     * );
+     *
+     * validateName("Alice"); // Passed("Alice")
+     * validateName("");      // Failed(["Name is required"])
+     * ```
+     */
+    Predicate: (pred, onFalse) => (a) => pred(a) ? makePassed(a) : makeFailed(onFalse(a)),
+    /**
+     * Creates a Validation from a nullable value.
+     * If the value is null or undefined, returns Failed with the error from onNull.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
+     * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
+     * ```
+     */
+    nullable: (onNull) => (value) => value === null || value === void 0 ? makeFailed(onNull()) : makePassed(value),
+    /**
+     * Creates a Validation from a Maybe.
+     * If the Maybe is None, returns Failed with the error from onNone.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
+     * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
+     * ```
+     */
+    Maybe: (onNone) => (maybe) => Maybe.is.none(maybe) ? makeFailed(onNone()) : makePassed(maybe.value),
+    /**
+     * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
+     *
+     * Useful when bridging from error-short-circuiting `Result` pipelines into
+     * error-accumulating `Validation` pipelines.
+     *
+     * @example
+     * ```ts
+     * Validation.from.Result(Result.make.ok(42));       // Passed(42)
+     * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
+     * ```
+     */
+    Result: (data) => data.kind === "Ok" ? makePassed(data.value) : makeFailed(data.error)
+  },
+  /**
+   * Transforms the success value inside a Validation.
+   *
+   * @example
+   * ```ts
+   * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
+   * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
+   * ```
+   */
+  map: (f) => (data) => isPassed(data) ? makePassed(f(data.value)) : data,
+  /**
+   * Transforms the error list inside a Validation.
+   *
+   * @example
+   * ```ts
+   * pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
+   * ```
+   */
+  mapError: (f) => (data) => isFailed(data) ? makeFailedAll(data.errors.map(f)) : data,
+  /**
+   * Applies a function wrapped in a Validation to a value wrapped in a Validation.
+   * Accumulates errors from both sides.
+   *
+   * @example
+   * ```ts
+   * const add = (a: number) => (b: number) => a + b;
+   * pipe(
+   *   Validation.make.passed(add),
+   *   Validation.ap(Validation.make.passed(5)),
+   *   Validation.ap(Validation.make.passed(3))
+   * ); // Passed(8)
+   *
+   * pipe(
+   *   Validation.make.passed(add),
+   *   Validation.ap(Validation.make.failed<string>("bad a")),
+   *   Validation.ap(Validation.make.failed<string>("bad b"))
+   * ); // Failed(["bad a", "bad b"])
+   * ```
+   */
+  ap: (arg) => (data) => {
+    if (isPassed(data)) {
+      return isPassed(arg) ? makePassed(data.value(arg.value)) : makeFailedAll(arg.errors);
+    }
+    return isPassed(arg) ? makeFailedAll(data.errors) : makeFailedAll([...data.errors, ...arg.errors]);
+  },
+  /**
+   * Applies a function wrapped in a Validation to a value wrapped in a Validation,
+   * using a custom error concatenator function when both sides fail.
+   *
+   * @example
+   * ```ts
+   * const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
+   *   [...e1, ...e2];
+   * pipe(fnVal, Validation.apCustom(concat)(argVal));
+   * ```
+   */
+  apCustom: (concat2) => (arg) => (data) => {
+    if (isPassed(data)) {
+      return isPassed(arg) ? makePassed(data.value(arg.value)) : makeFailedAll(arg.errors);
+    }
+    return isPassed(arg) ? makeFailedAll(data.errors) : makeFailedAll(concat2(data.errors, arg.errors));
+  },
+  /**
+   * Extracts the value from a Validation by providing handlers for both cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.passed(42),
+   *   Validation.fold(
+   *     errors => `Errors: ${errors.join(", ")}`,
+   *     value => `Value: ${value}`
+   *   )
+   * );
+   * ```
+   */
+  fold: (onFailed, onPassed) => (data) => isPassed(data) ? onPassed(data.value) : onFailed(data.errors),
+  /**
+   * Pattern matches on a Validation, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   validation,
+   *   Validation.match({
+   *     passed: value => `Got ${value}`,
+   *     failed: errors => `Failed: ${errors.join(", ")}`
+   *   })
+   * );
+   * ```
+   */
+  match: (cases) => (data) => isPassed(data) ? cases.passed(data.value) : cases.failed(data.errors),
+  /**
+   * Returns the success value or a default value if the Validation is failed.
+   * The default can be a different type, widening the result to `A | B`.
+   *
+   * @example
+   * ```ts
+   * pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
+   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
+   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+   * ```
+   */
+  getOrElse: (defaultValue) => (data) => isPassed(data) ? data.value : defaultValue(),
+  /**
+   * Executes a side effect on the success value without changing the Validation.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.passed(5),
+   *   Validation.tap(n => console.log("Value:", n)),
+   *   Validation.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: (f) => (data) => {
+    if (isPassed(data)) {
       f(data.value);
     }
     return data;
-  };
-  Validation2.tapError = (f) => (data) => {
-    if (is.failed(data)) {
+  },
+  /**
+   * Executes a side effect on the accumulated errors without changing the Validation.
+   * Useful for logging or reporting validation failures.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.failed("Name required"),
+   *   Validation.tapError(errors => console.error("validation failed:", errors)),
+   *   Validation.map(toUser)
+   * );
+   * ```
+   */
+  tapError: (f) => (data) => {
+    if (isFailed(data)) {
       f(data.errors);
     }
     return data;
-  };
-  Validation2.recover = (fallback) => (data) => is.passed(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (isBlocked, fallback) => (data) => is.failed(data) && !data.errors.some(isBlocked) ? fallback() : data;
-  let to;
-  ((to2) => {
-    function Result2(arg) {
-      if (typeof arg === "function") {
-        const combine = arg;
-        return (val) => is.passed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
-      }
-      return is.passed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
-    }
-    to2.Result = Result2;
-    to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
-  })(to = Validation2.to || (Validation2.to = {}));
-  Validation2.product = (first, second) => {
-    if (is.passed(first)) {
-      return is.passed(second) ? make.passed([first.value, second.value]) : make.failedAll(second.errors);
-    }
-    return is.passed(second) ? make.failedAll(first.errors) : make.failedAll([...first.errors, ...second.errors]);
-  };
-  Validation2.productAll = (data) => {
-    const values = [];
+  },
+  /**
+   * Recovers from a Failed state by providing a fallback Validation.
+   * The fallback receives the accumulated error list so callers can inspect which errors occurred.
+   * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+   */
+  recover: (fallback) => (data) => isPassed(data) ? data : fallback(data.errors),
+  /**
+   * Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
+   * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.failed("field-error"),
+   *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
+   * ); // Passed(0)
+   * ```
+   */
+  recoverUnless: (isBlocked, fallback) => (data) => isFailed(data) && !data.errors.some(isBlocked) ? fallback() : data,
+  // --- to ---
+  to: {
+    /**
+     * Converts a Validation to a Result.
+     * Passed becomes Ok.
+     * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
+     * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
+     *
+     * @example
+     * ```ts
+     * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
+     * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
+     * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
+     * ```
+     */
+    Result: toResult,
+    /**
+     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
+     * (errors are discarded).
+     *
+     * @example
+     * ```ts
+     * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
+     * Validation.to.Maybe(Validation.make.failed("bad"));  // None
+     * ```
+     */
+    Maybe: (data) => isPassed(data) ? Maybe.make.some(data.value) : Maybe.make.none()
+  },
+  /**
+   * Combines two independent Validation instances into a tuple.
+   * If both are Passed, returns Passed with both values as a tuple.
+   * If either is Failed, accumulates errors from both sides.
+   *
+   * @example
+   * ```ts
+   * Validation.product(
+   *   Validation.make.passed("alice"),
+   *   Validation.make.passed(30)
+   * ); // Passed(["alice", 30])
+   *
+   * Validation.product(
+   *   Validation.make.failed("Name required"),
+   *   Validation.make.failed("Age must be >= 0")
+   * ); // Failed(["Name required", "Age must be >= 0"])
+   * ```
+   */
+  product: (first, second) => {
+    if (isPassed(first)) {
+      return isPassed(second) ? makePassed([first.value, second.value]) : makeFailedAll(second.errors);
+    }
+    return isPassed(second) ? makeFailedAll(first.errors) : makeFailedAll([...first.errors, ...second.errors]);
+  },
+  /**
+   * Combines a non-empty list of Validation instances, accumulating all errors.
+   * If all are Passed, returns Passed with all values collected into an array.
+   * If any are Failed, returns Failed with all accumulated errors.
+   *
+   * @example
+   * ```ts
+   * Validation.productAll([
+   *   validateName(name),
+   *   validateEmail(email),
+   *   validateAge(age)
+   * ]);
+   * // Passed([name, email, age]) or Failed([...all errors])
+   * ```
+   */
+  productAll: (data) => {
+    const values3 = [];
     const errors = [];
     for (const v of data) {
-      if (is.passed(v)) {
-        values.push(v.value);
+      if (isPassed(v)) {
+        values3.push(v.value);
       } else {
         errors.push(...v.errors);
       }
     }
-    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(values);
-  };
-  Validation2.struct = (fields) => {
+    return isNonEmptyArr(errors) ? makeFailedAll(errors) : makePassed(values3);
+  },
+  /**
+   * Combines a record of Validations into a single Validation of a record.
+   * Accumulates all failed branches' errors.
+   *
+   * @example
+   * ```ts
+   * Validation.struct({
+   *   name: Validation.make.passed("Alice"),
+   *   age: Validation.make.passed(30)
+   * }); // Passed({ name: "Alice", age: 30 })
+   *
+   * Validation.struct({
+   *   name: Validation.make.failed("Name required"),
+   *   age: Validation.make.failed("Age must be >= 0")
+   * }); // Failed(["Name required", "Age must be >= 0"])
+   * ```
+   */
+  struct: (fields) => {
     const record = {};
     const errors = [];
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const val = fields[key];
-        if (is.passed(val)) {
+        if (isPassed(val)) {
           record[key] = val.value;
         } else {
           errors.push(...val.errors);
         }
       }
     }
-    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
-  };
-})(Validation || (Validation = {}));
+    return isNonEmptyArr(errors) ? makeFailedAll(errors) : makePassed(record);
+  }
+};
 
 // src/Data/Arr.ts
 var ArrMaybe;
@@ -314,448 +1235,499 @@ var ArrTask;
   ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
   ArrTask2.Result = ArrTaskResult;
 })(ArrTask || (ArrTask = {}));
-var ArrNonEmpty;
-((ArrNonEmpty2) => {
-  ArrNonEmpty2.singleton = (value) => [value];
-  let from;
-  ((from2) => {
-    from2.Array = (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none();
-  })(from = ArrNonEmpty2.from || (ArrNonEmpty2.from = {}));
-  ArrNonEmpty2.head = (data) => data[0];
-  ArrNonEmpty2.last = (data) => data[data.length - 1];
-  ArrNonEmpty2.tail = (data) => data.slice(1);
-  ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
-  ArrNonEmpty2.map = (f) => (data) => Arr.map(f)(data);
-  ArrNonEmpty2.mapWithIndex = (f) => (data) => Arr.mapWithIndex(f)(data);
-  ArrNonEmpty2.intersperse = (sep) => (data) => Arr.intersperse(sep)(data);
-  ArrNonEmpty2.concat = (other) => (data) => Arr.concat(other)(data);
-  ArrNonEmpty2.reverse = (data) => Arr.reverse(data);
-})(ArrNonEmpty || (ArrNonEmpty = {}));
-var Arr;
-((Arr2) => {
-  Arr2.head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
-  Arr2.last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
-  Arr2.tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
-  Arr2.init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
-  Arr2.findFirst = (predicate) => (data) => {
-    const idx = data.findIndex(predicate);
-    return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
-  };
-  Arr2.findLast = (predicate) => (data) => {
-    for (let i = data.length - 1; i >= 0; i--) {
-      if (predicate(data[i])) {
-        return Maybe.make.some(data[i]);
-      }
+var head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
+var last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
+var tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
+var init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
+var findFirst = (predicate) => (data) => {
+  const idx = data.findIndex(predicate);
+  return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
+};
+var findLast = (predicate) => (data) => {
+  for (let i = data.length - 1; i >= 0; i--) {
+    if (predicate(data[i])) {
+      return Maybe.make.some(data[i]);
     }
-    return Maybe.make.none();
-  };
-  Arr2.findIndex = (predicate) => (data) => {
-    const idx = data.findIndex(predicate);
-    return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.none();
-  };
-  Arr2.map = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      result[i] = f(data[i]);
+  }
+  return Maybe.make.none();
+};
+var findIndex = (predicate) => (data) => {
+  const idx = data.findIndex(predicate);
+  return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.none();
+};
+var map = (f) => (data) => {
+  const n = data.length;
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = f(data[i]);
+  }
+  return result;
+};
+var mapWithIndex = (f) => (data) => {
+  const n = data.length;
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = f(i, data[i]);
+  }
+  return result;
+};
+var filter = (predicate) => (data) => {
+  const n = data.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    if (predicate(data[i])) {
+      result.push(data[i]);
     }
-    return result;
-  };
-  Arr2.mapWithIndex = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      result[i] = f(i, data[i]);
+  }
+  return result;
+};
+var filterMap = (f) => (data) => {
+  const result = [];
+  for (let i = 0; i < data.length; i++) {
+    const mapped = f(data[i]);
+    if (mapped.kind === "Some") {
+      result.push(mapped.value);
     }
-    return result;
-  };
-  Arr2.filter = (predicate) => (data) => {
-    const n = data.length;
-    const result = [];
-    for (let i = 0; i < n; i++) {
-      if (predicate(data[i])) {
-        result.push(data[i]);
-      }
-    }
-    return result;
-  };
-  Arr2.filterMap = (f) => (data) => {
-    const result = [];
-    for (let i = 0; i < data.length; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "Some") {
-        result.push(mapped.value);
-      }
-    }
-    return result;
-  };
-  Arr2.partition = (predicate) => (data) => {
-    const pass = [];
-    const fail = [];
-    for (const a of data) {
-      (predicate(a) ? pass : fail).push(a);
-    }
-    return [pass, fail];
-  };
-  Arr2.compact = (data) => {
-    const result = [];
-    for (const item of data) {
-      if (item.kind === "Some") {
-        result.push(item.value);
-      }
-    }
-    return result;
-  };
-  Arr2.separate = (data) => {
-    const errors = [];
-    const successes = [];
-    for (const item of data) {
-      if (item.kind === "Ok") {
-        successes.push(item.value);
-      } else {
-        errors.push(item.error);
-      }
-    }
-    return [errors, successes];
-  };
-  Arr2.partitionMap = (f) => (data) => {
-    const errors = [];
-    const successes = [];
-    for (const item of data) {
-      const mapped = f(item);
-      if (mapped.kind === "Ok") {
-        successes.push(mapped.value);
-      } else {
-        errors.push(mapped.error);
-      }
-    }
-    return [errors, successes];
-  };
-  Arr2.groupBy = (f) => (data) => {
-    const result = {};
-    for (const a of data) {
-      const key = f(a);
-      if (!result[key]) {
-        result[key] = [];
-      }
-      result[key].push(a);
-    }
-    return result;
-  };
-  Arr2.uniq = (data) => data.length <= 1 ? data : [...new Set(data)];
-  Arr2.uniqBy = (f) => (data) => {
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const a of data) {
-      const key = f(a);
-      if (!seen.has(key)) {
-        seen.add(key);
-        result.push(a);
-      }
-    }
-    return result;
-  };
-  Arr2.uniqWith = (eq) => (data) => {
-    const result = [];
-    for (const a of data) {
-      if (!result.some((x) => eq(x, a))) {
-        result.push(a);
-      }
-    }
-    return result;
-  };
-  Arr2.sortBy = (compare) => (data) => {
-    const arr = data;
-    if (typeof arr.toSorted === "function") {
-      return arr.toSorted(compare);
-    }
-    return [...data].sort(compare);
-  };
-  Arr2.sortWith = (ord) => (data) => {
-    const arr = data;
-    if (typeof arr.toSorted === "function") {
-      return arr.toSorted(ord);
-    }
-    return [...data].sort(ord);
-  };
-  Arr2.zip = (other) => (data) => {
-    const len = Math.min(data.length, other.length);
-    const result = new Array(len);
-    for (let i = 0; i < len; i++) {
-      result[i] = [data[i], other[i]];
-    }
-    return result;
-  };
-  Arr2.zipWith = (f) => (other) => (data) => {
-    const len = Math.min(data.length, other.length);
-    const result = new Array(len);
-    for (let i = 0; i < len; i++) {
-      result[i] = f(data[i], other[i]);
-    }
-    return result;
-  };
-  Arr2.intersperse = (sep) => (data) => {
-    if (data.length <= 1) {
-      return data;
-    }
-    const result = [data[0]];
-    for (let i = 1; i < data.length; i++) {
-      result.push(sep, data[i]);
-    }
-    return result;
-  };
-  Arr2.concat = (other) => (data) => [...data, ...other];
-  Arr2.chunksOf = (n) => (data) => {
-    if (n <= 0) {
-      return [];
-    }
-    const result = [];
-    for (let i = 0; i < data.length; i += n) {
-      result.push(data.slice(i, i + n));
-    }
-    return result;
-  };
-  Arr2.flatten = (data) => {
-    let totalLen = 0;
-    const outerLen = data.length;
-    for (let i = 0; i < outerLen; i++) {
-      totalLen += data[i].length;
-    }
-    const result = new Array(totalLen);
-    let idx = 0;
-    for (let i = 0; i < outerLen; i++) {
-      const chunk = data[i];
-      const innerLen = chunk.length;
-      for (let j = 0; j < innerLen; j++) {
-        result[idx++] = chunk[j];
-      }
-    }
-    return result;
-  };
-  Arr2.flatMap = (f) => (data) => {
-    const n = data.length;
-    const result = [];
-    for (let i = 0; i < n; i++) {
-      const chunk = f(data[i]);
-      const m = chunk.length;
-      for (let j = 0; j < m; j++) {
-        result.push(chunk[j]);
-      }
-    }
-    return result;
-  };
-  Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
-  const _traverseTask = Object.assign((f) => ArrTask.traverse(f), {
-    Result: ArrTaskResult.traverse
-  });
-  const _sequenceTask = Object.assign((data) => ArrTask.sequence(data), {
-    Result: ArrTaskResult.sequence
-  });
-  let traverse;
-  ((traverse2) => {
-    traverse2.Maybe = ArrMaybe.traverse;
-    traverse2.Result = ArrResult.traverse;
-    traverse2.Task = _traverseTask;
-  })(traverse = Arr2.traverse || (Arr2.traverse = {}));
-  let sequence;
-  ((sequence2) => {
-    sequence2.Maybe = ArrMaybe.sequence;
-    sequence2.Result = ArrResult.sequence;
-    sequence2.Task = _sequenceTask;
-  })(sequence = Arr2.sequence || (Arr2.sequence = {}));
-  let is;
-  ((is2) => {
-    is2.empty = (data) => data.length === 0;
-    is2.nonEmpty = (data) => isNonEmptyArr(data);
-  })(is = Arr2.is || (Arr2.is = {}));
-  Arr2.prepend = (value) => (data) => [value, ...data];
-  Arr2.append = (value) => (data) => [...data, value];
-  Arr2.size = (data) => data.length;
-  Arr2.some = (predicate) => (data) => {
-    const n = data.length;
-    for (let i = 0; i < n; i++) {
-      if (predicate(data[i])) {
-        return true;
-      }
+  }
+  return result;
+};
+var partition = (predicate) => (data) => {
+  const pass = [];
+  const fail = [];
+  for (const a of data) {
+    (predicate(a) ? pass : fail).push(a);
+  }
+  return [pass, fail];
+};
+var compact = (data) => {
+  const result = [];
+  for (const item of data) {
+    if (item.kind === "Some") {
+      result.push(item.value);
     }
-    return false;
-  };
-  Arr2.every = (predicate) => (data) => {
-    const n = data.length;
-    for (let i = 0; i < n; i++) {
-      if (!predicate(data[i])) {
-        return false;
-      }
+  }
+  return result;
+};
+var separate = (data) => {
+  const errors = [];
+  const successes = [];
+  for (const item of data) {
+    if (item.kind === "Ok") {
+      successes.push(item.value);
+    } else {
+      errors.push(item.error);
     }
-    return true;
-  };
-  Arr2.reverse = (data) => [...data].toReversed();
-  Arr2.insertAt = (index, item) => (data) => {
-    const i = Math.max(0, Math.min(index, data.length));
-    const arr = data;
-    if (typeof arr.toSpliced === "function") {
-      return arr.toSpliced(i, 0, item);
-    }
-    const result = [...data];
-    result.splice(i, 0, item);
-    return result;
-  };
-  Arr2.removeAt = (index) => (data) => {
-    if (index < 0 || index >= data.length) {
-      return data;
+  }
+  return [errors, successes];
+};
+var partitionMap = (f) => (data) => {
+  const errors = [];
+  const successes = [];
+  for (const item of data) {
+    const mapped = f(item);
+    if (mapped.kind === "Ok") {
+      successes.push(mapped.value);
+    } else {
+      errors.push(mapped.error);
     }
-    const arr = data;
-    if (typeof arr.toSpliced === "function") {
-      return arr.toSpliced(index, 1);
+  }
+  return [errors, successes];
+};
+var groupBy = (f) => (data) => {
+  const result = {};
+  for (const a of data) {
+    const key = f(a);
+    if (!result[key]) {
+      result[key] = [];
+    }
+    result[key].push(a);
+  }
+  return result;
+};
+var uniq = (data) => data.length <= 1 ? data : [...new Set(data)];
+var uniqBy = (f) => (data) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const a of data) {
+    const key = f(a);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(a);
     }
-    const result = [...data];
-    result.splice(index, 1);
-    return result;
-  };
-  Arr2.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
-  Arr2.drop = (n) => (data) => data.slice(n);
-  Arr2.takeWhile = (predicate) => (data) => {
-    const result = [];
-    for (const a of data) {
-      if (!predicate(a)) {
-        break;
-      }
+  }
+  return result;
+};
+var uniqWith = (eq) => (data) => {
+  const result = [];
+  for (const a of data) {
+    if (!result.some((x) => eq(x, a))) {
       result.push(a);
     }
-    return result;
-  };
-  Arr2.dropWhile = (predicate) => (data) => {
-    let i = 0;
-    while (i < data.length && predicate(data[i])) {
-      i++;
+  }
+  return result;
+};
+var sortBy = (compare) => (data) => {
+  const arr = data;
+  if (typeof arr.toSorted === "function") {
+    return arr.toSorted(compare);
+  }
+  return [...data].sort(compare);
+};
+var sortWith = (ord) => (data) => {
+  const arr = data;
+  if (typeof arr.toSorted === "function") {
+    return arr.toSorted(ord);
+  }
+  return [...data].sort(ord);
+};
+var zip = (other) => (data) => {
+  const len = Math.min(data.length, other.length);
+  const result = new Array(len);
+  for (let i = 0; i < len; i++) {
+    result[i] = [data[i], other[i]];
+  }
+  return result;
+};
+var zipWith = (f) => (other) => (data) => {
+  const len = Math.min(data.length, other.length);
+  const result = new Array(len);
+  for (let i = 0; i < len; i++) {
+    result[i] = f(data[i], other[i]);
+  }
+  return result;
+};
+var intersperse = (sep) => (data) => {
+  if (data.length <= 1) {
+    return data;
+  }
+  const result = [data[0]];
+  for (let i = 1; i < data.length; i++) {
+    result.push(sep, data[i]);
+  }
+  return result;
+};
+var concat = (other) => (data) => [...data, ...other];
+var chunksOf = (n) => (data) => {
+  if (n <= 0) {
+    return [];
+  }
+  const result = [];
+  for (let i = 0; i < data.length; i += n) {
+    result.push(data.slice(i, i + n));
+  }
+  return result;
+};
+var flatten = (data) => {
+  let totalLen = 0;
+  const outerLen = data.length;
+  for (let i = 0; i < outerLen; i++) {
+    totalLen += data[i].length;
+  }
+  const result = new Array(totalLen);
+  let idx = 0;
+  for (let i = 0; i < outerLen; i++) {
+    const chunk = data[i];
+    const innerLen = chunk.length;
+    for (let j = 0; j < innerLen; j++) {
+      result[idx++] = chunk[j];
     }
-    return data.slice(i);
-  };
-  Arr2.scan = (initial, f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    let acc = initial;
-    for (let i = 0; i < n; i++) {
-      acc = f(acc, data[i]);
-      result[i] = acc;
+  }
+  return result;
+};
+var flatMap = (f) => (data) => {
+  const n = data.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const chunk = f(data[i]);
+    const m = chunk.length;
+    for (let j = 0; j < m; j++) {
+      result.push(chunk[j]);
     }
-    return result;
-  };
-  Arr2.splitAt = (index) => (data) => {
-    const i = Math.max(0, index);
-    return [data.slice(0, i), data.slice(i)];
-  };
-  Arr2.partitionMaybe = (f) => (data) => {
-    const failures = [];
-    const successes = [];
-    for (let i = 0; i < data.length; i++) {
-      const res = f(data[i]);
-      if (res.kind === "Some") {
-        successes.push(res.value);
-      } else {
-        failures.push(data[i]);
-      }
+  }
+  return result;
+};
+var reduce = (initial, f) => (data) => data.reduce(f, initial);
+var _traverseTask = Object.assign((f) => ArrTask.traverse(f), {
+  Result: ArrTaskResult.traverse
+});
+var _sequenceTask = Object.assign((data) => ArrTask.sequence(data), {
+  Result: ArrTaskResult.sequence
+});
+var prepend = (value) => (data) => [value, ...data];
+var append = (value) => (data) => [...data, value];
+var size = (data) => data.length;
+var some = (predicate) => (data) => {
+  const n = data.length;
+  for (let i = 0; i < n; i++) {
+    if (predicate(data[i])) {
+      return true;
     }
-    return [failures, successes];
-  };
-  Arr2.at = (index) => (data) => {
-    const targetIndex = index < 0 ? data.length + index : index;
-    if (targetIndex < 0 || targetIndex >= data.length) {
-      return Maybe.make.none();
+  }
+  return false;
+};
+var every = (predicate) => (data) => {
+  const n = data.length;
+  for (let i = 0; i < n; i++) {
+    if (!predicate(data[i])) {
+      return false;
     }
-    return Maybe.make.some(data[targetIndex]);
-  };
-  Arr2.findMap = (f) => (data) => {
-    for (let i = 0; i < data.length; i++) {
-      const res = f(data[i]);
-      if (res.kind === "Some") {
-        return res;
-      }
+  }
+  return true;
+};
+var reverse = (data) => [...data].toReversed();
+var insertAt = (index, item) => (data) => {
+  const i = Math.max(0, Math.min(index, data.length));
+  const arr = data;
+  if (typeof arr.toSpliced === "function") {
+    return arr.toSpliced(i, 0, item);
+  }
+  const result = [...data];
+  result.splice(i, 0, item);
+  return result;
+};
+var removeAt = (index) => (data) => {
+  if (index < 0 || index >= data.length) {
+    return data;
+  }
+  const arr = data;
+  if (typeof arr.toSpliced === "function") {
+    return arr.toSpliced(index, 1);
+  }
+  const result = [...data];
+  result.splice(index, 1);
+  return result;
+};
+var take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
+var drop = (n) => (data) => data.slice(n);
+var takeWhile = (predicate) => (data) => {
+  const result = [];
+  for (const a of data) {
+    if (!predicate(a)) {
+      break;
+    }
+    result.push(a);
+  }
+  return result;
+};
+var dropWhile = (predicate) => (data) => {
+  let i = 0;
+  while (i < data.length && predicate(data[i])) {
+    i++;
+  }
+  return data.slice(i);
+};
+var scan = (initial, f) => (data) => {
+  const n = data.length;
+  const result = new Array(n);
+  let acc = initial;
+  for (let i = 0; i < n; i++) {
+    acc = f(acc, data[i]);
+    result[i] = acc;
+  }
+  return result;
+};
+var splitAt = (index) => (data) => {
+  const i = Math.max(0, index);
+  return [data.slice(0, i), data.slice(i)];
+};
+var partitionMaybe = (f) => (data) => {
+  const failures = [];
+  const successes = [];
+  for (let i = 0; i < data.length; i++) {
+    const res = f(data[i]);
+    if (res.kind === "Some") {
+      successes.push(res.value);
+    } else {
+      failures.push(data[i]);
     }
+  }
+  return [failures, successes];
+};
+var at = (index) => (data) => {
+  const targetIndex = index < 0 ? data.length + index : index;
+  if (targetIndex < 0 || targetIndex >= data.length) {
     return Maybe.make.none();
-  };
-  Arr2.indexBy = (keyFn) => (data) => {
-    const map2 = new globalThis.Map();
-    for (let i = 0; i < data.length; i++) {
-      map2.set(keyFn(data[i]), data[i]);
-    }
-    return map2;
-  };
-  Arr2.frequencies = (data) => {
-    const map2 = new globalThis.Map();
-    for (let i = 0; i < data.length; i++) {
-      const item = data[i];
-      map2.set(item, (map2.get(item) ?? 0) + 1);
-    }
-    return map2;
-  };
-  Arr2.chunkBy = (keyFn) => (data) => {
-    if (data.length === 0) {
-      return [];
-    }
-    const result = [];
-    let currentChunk = [data[0]];
-    let currentKey = keyFn(data[0]);
-    for (let i = 1; i < data.length; i++) {
-      const item = data[i];
-      const key = keyFn(item);
-      if (Object.is(key, currentKey)) {
-        currentChunk.push(item);
-      } else {
-        result.push(currentChunk);
-        currentChunk = [item];
-        currentKey = key;
-      }
-    }
-    result.push(currentChunk);
-    return result;
-  };
-  Arr2.dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
-    if (data.length === 0) {
-      return [];
-    }
-    const result = [data[0]];
-    for (let i = 1; i < data.length; i++) {
-      if (!eq(data[i], result[result.length - 1])) {
-        result.push(data[i]);
-      }
-    }
-    return result;
-  };
-  Arr2.windowed = (size2, options) => (data) => {
-    const step = options?.step ?? 1;
-    if (size2 <= 0 || step <= 0 || data.length < size2) {
-      return [];
+  }
+  return Maybe.make.some(data[targetIndex]);
+};
+var findMap = (f) => (data) => {
+  for (let i = 0; i < data.length; i++) {
+    const res = f(data[i]);
+    if (res.kind === "Some") {
+      return res;
     }
-    const result = [];
-    for (let i = 0; i <= data.length - size2; i += step) {
-      result.push(data.slice(i, i + size2));
+  }
+  return Maybe.make.none();
+};
+var indexBy = (keyFn) => (data) => {
+  const resultMap = new globalThis.Map();
+  for (let i = 0; i < data.length; i++) {
+    resultMap.set(keyFn(data[i]), data[i]);
+  }
+  return resultMap;
+};
+var frequencies = (data) => {
+  const resultMap = new globalThis.Map();
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+    resultMap.set(item, (resultMap.get(item) ?? 0) + 1);
+  }
+  return resultMap;
+};
+var chunkBy = (keyFn) => (data) => {
+  if (data.length === 0) {
+    return [];
+  }
+  const result = [];
+  let currentChunk = [data[0]];
+  let currentKey = keyFn(data[0]);
+  for (let i = 1; i < data.length; i++) {
+    const item = data[i];
+    const key = keyFn(item);
+    if (Object.is(key, currentKey)) {
+      currentChunk.push(item);
+    } else {
+      result.push(currentChunk);
+      currentChunk = [item];
+      currentKey = key;
     }
-    return result;
-  };
-  Arr2.unfold = (initial, f) => {
-    const result = [];
-    let currentState = initial;
-    while (true) {
-      const next = f(currentState);
-      if (next.kind === "None") {
-        break;
-      }
-      const [item, nextState] = next.value;
-      result.push(item);
-      currentState = nextState;
+  }
+  result.push(currentChunk);
+  return result;
+};
+var dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
+  if (data.length === 0) {
+    return [];
+  }
+  const result = [data[0]];
+  for (let i = 1; i < data.length; i++) {
+    if (!eq(data[i], result[result.length - 1])) {
+      result.push(data[i]);
     }
-    return result;
-  };
-  Arr2.NonEmpty = ArrNonEmpty;
-})(Arr || (Arr = {}));
+  }
+  return result;
+};
+var windowed = (windowSize, options) => (data) => {
+  const step = options?.step ?? 1;
+  if (windowSize <= 0 || step <= 0 || data.length < windowSize) {
+    return [];
+  }
+  const result = [];
+  for (let i = 0; i <= data.length - windowSize; i += step) {
+    result.push(data.slice(i, i + windowSize));
+  }
+  return result;
+};
+var unfold = (initial, f) => {
+  const result = [];
+  let currentState = initial;
+  while (true) {
+    const next = f(currentState);
+    if (next.kind === "None") {
+      break;
+    }
+    const [item, nextState] = next.value;
+    result.push(item);
+    currentState = nextState;
+  }
+  return result;
+};
+var ArrFrom = {
+  Array: (data) => data.length > 0 ? Maybe.make.some(data) : Maybe.make.none()
+};
+var ArrIs = {
+  empty: (data) => data.length === 0,
+  nonEmpty: (data) => isNonEmptyArr(data)
+};
+var ArrNonEmpty = {
+  singleton: (value) => [value],
+  from: {
+    Array: (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none()
+  },
+  head: (data) => data[0],
+  last: (data) => data[data.length - 1],
+  tail: (data) => data.slice(1),
+  reduce: (f) => (data) => data.reduce(f),
+  map: (f) => (data) => map(f)(data),
+  mapWithIndex: (f) => (data) => mapWithIndex(f)(data),
+  intersperse: (sep) => (data) => intersperse(sep)(data),
+  concat: (other) => (data) => concat(other)(data),
+  reverse: (data) => reverse(data)
+};
+var Arr = {
+  head,
+  last,
+  tail,
+  init,
+  findFirst,
+  findLast,
+  findIndex,
+  map,
+  mapWithIndex,
+  filter,
+  filterMap,
+  partition,
+  compact,
+  separate,
+  partitionMap,
+  groupBy,
+  uniq,
+  uniqBy,
+  uniqWith,
+  sortBy,
+  sortWith,
+  zip,
+  zipWith,
+  intersperse,
+  concat,
+  chunksOf,
+  flatten,
+  flatMap,
+  reduce,
+  prepend,
+  append,
+  size,
+  some,
+  every,
+  reverse,
+  insertAt,
+  removeAt,
+  take,
+  drop,
+  takeWhile,
+  dropWhile,
+  scan,
+  splitAt,
+  partitionMaybe,
+  at,
+  findMap,
+  indexBy,
+  frequencies,
+  chunkBy,
+  dedupeAdjacent,
+  windowed,
+  unfold,
+  from: ArrFrom,
+  is: ArrIs,
+  traverse: { Maybe: ArrMaybe.traverse, Result: ArrResult.traverse, Task: _traverseTask },
+  sequence: { Maybe: ArrMaybe.sequence, Result: ArrResult.sequence, Task: _sequenceTask },
+  NonEmpty: ArrNonEmpty
+};
 
 // src/Data/BigNum.ts
-var BigNum;
-((BigNum2) => {
-  let from;
-  ((from2) => {
-    from2.string = (s) => {
+var BigNum = {
+  // --- from ---
+  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) => {
       try {
         if (s.trim() === "") {
           return Maybe.make.none();
@@ -764,272 +1736,542 @@ var BigNum;
       } catch {
         return Maybe.make.none();
       }
-    };
-    from2.number = (n) => {
+    },
+    /**
+     * 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) => {
       if (!Number.isInteger(n) || n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
         return Maybe.make.none();
       }
       return Maybe.make.some(BigInt(n));
-    };
-  })(from = BigNum2.from || (BigNum2.from = {}));
-  let to;
-  ((to2) => {
-    to2.number = (b) => {
+    }
+  },
+  // --- to ---
+  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) => {
       if (b < BigInt(Number.MIN_SAFE_INTEGER) || b > BigInt(Number.MAX_SAFE_INTEGER)) {
         return Maybe.make.none();
       }
       return Maybe.make.some(Number(b));
-    };
-  })(to = BigNum2.to || (BigNum2.to = {}));
-  BigNum2.add = (b) => (a) => a + b;
-  BigNum2.sub = (b) => (a) => a - b;
-  BigNum2.mul = (b) => (a) => a * b;
-  BigNum2.div = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a / b);
-  BigNum2.mod = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a % b);
-  BigNum2.clamp = (min2, max2) => (a) => a < min2 ? min2 : a > max2 ? max2 : a;
-  BigNum2.inRange = (start, end) => (a) => a >= start && a < end;
-  BigNum2.abs = (a) => a < 0n ? -a : a;
-  BigNum2.min = (b) => (a) => a < b ? a : b;
-  BigNum2.max = (b) => (a) => a > b ? a : b;
-})(BigNum || (BigNum = {}));
+    }
+  },
+  /**
+   * Adds `b` to `a`. Data-last curried signature: `add(b)(a)` = `a + b`.
+   *
+   * @example
+   * ```ts
+   * pipe(10n, BigNum.add(5n)); // 15n
+   * ```
+   */
+  add: (b) => (a) => a + b,
+  /**
+   * Subtracts `b` from `a`. Data-last curried signature: `sub(b)(a)` = `a - b`.
+   *
+   * @example
+   * ```ts
+   * pipe(10n, BigNum.sub(3n)); // 7n
+   * ```
+   */
+  sub: (b) => (a) => a - b,
+  /**
+   * Multiplies `a` by `b`. Data-last curried signature: `mul(b)(a)` = `a * b`.
+   *
+   * @example
+   * ```ts
+   * pipe(6n, BigNum.mul(7n)); // 42n
+   * ```
+   */
+  mul: (b) => (a) => a * b,
+  /**
+   * 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) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a / b),
+  /**
+   * 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) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a % b),
+  /**
+   * Clamps `a` between `min` and `max` (inclusive).
+   *
+   * @example
+   * ```ts
+   * pipe(150n, BigNum.clamp(0n, 100n)); // 100n
+   * ```
+   */
+  clamp: (min, max) => (a) => a < min ? min : a > max ? max : a,
+  /**
+   * 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, end) => (a) => a >= start && a < end,
+  /**
+   * Returns absolute value of a `bigint`.
+   *
+   * @example
+   * ```ts
+   * BigNum.abs(-42n); // 42n
+   * ```
+   */
+  abs: (a) => a < 0n ? -a : a,
+  /**
+   * Returns the minimum of `a` and `b`.
+   *
+   * @example
+   * ```ts
+   * pipe(10n, BigNum.min(5n)); // 5n
+   * ```
+   */
+  min: (b) => (a) => a < b ? a : b,
+  /**
+   * Returns the maximum of `a` and `b`.
+   *
+   * @example
+   * ```ts
+   * pipe(10n, BigNum.max(5n)); // 10n
+   * ```
+   */
+  max: (b) => (a) => a > b ? a : b
+};
 
 // src/Data/Dict.ts
-var DictNonEmpty;
-((DictNonEmpty2) => {
-  DictNonEmpty2.singleton = (key, value) => new globalThis.Map([[key, value]]);
-  let from;
-  ((from2) => {
-    from2.Map = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
-  })(from = DictNonEmpty2.from || (DictNonEmpty2.from = {}));
-  DictNonEmpty2.keys = (m) => Dict.keys(m);
-  DictNonEmpty2.values = (m) => Dict.values(m);
-  DictNonEmpty2.entries = (m) => Dict.entries(m);
-  DictNonEmpty2.reduce = (f) => (m) => (0, DictNonEmpty2.values)(m).reduce(f);
-  DictNonEmpty2.map = (f) => (m) => Dict.map(f)(m);
-  DictNonEmpty2.mapWithKey = (f) => (m) => Dict.mapWithKey(f)(m);
-})(DictNonEmpty || (DictNonEmpty = {}));
-var Dict;
-((Dict2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (m) => m.size === 0;
-    is2.nonEmpty = (m) => m.size > 0;
-  })(is = Dict2.is || (Dict2.is = {}));
-  Dict2.empty = () => new globalThis.Map();
-  Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
-  let from;
-  ((from2) => {
-    from2.entries = (entries3) => new globalThis.Map(entries3);
-    from2.Record = (rec) => new globalThis.Map(Object.entries(rec));
-  })(from = Dict2.from || (Dict2.from = {}));
-  Dict2.groupBy = (keyFn) => (items) => {
-    const result = new globalThis.Map();
-    for (const item of items) {
-      const key = keyFn(item);
-      const arr = result.get(key);
-      if (arr !== void 0) {
-        arr.push(item);
-      } else {
-        result.set(key, [item]);
-      }
-    }
-    return result;
-  };
-  Dict2.has = (key) => (m) => m.has(key);
-  Dict2.lookup = (key) => (m) => m.has(key) ? Maybe.make.some(m.get(key)) : Maybe.make.none();
-  Dict2.size = (m) => m.size;
-  Dict2.keys = (m) => [...m.keys()];
-  Dict2.values = (m) => [...m.values()];
-  Dict2.entries = (m) => [...m.entries()];
-  Dict2.insert = (key, value) => (m) => {
-    const result = new globalThis.Map(m);
-    result.set(key, value);
-    return result;
-  };
-  Dict2.remove = (key) => (m) => {
-    if (!m.has(key)) {
-      return m;
-    }
-    const result = new globalThis.Map(m);
-    result.delete(key);
-    return result;
-  };
-  Dict2.upsert = (key, f) => (m) => {
-    const result = new globalThis.Map(m);
-    result.set(key, f((0, Dict2.lookup)(key)(m)));
-    return result;
-  };
-  Dict2.map = (f) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      result.set(k, f(v));
-    }
-    return result;
-  };
-  Dict2.mapWithKey = (f) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      result.set(k, f(k, v));
-    }
-    return result;
-  };
-  Dict2.filter = (predicate) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (predicate(v)) {
-        result.set(k, v);
-      }
-    }
-    return result;
-  };
-  Dict2.filterWithKey = (predicate) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (predicate(k, v)) {
-        result.set(k, v);
-      }
+var DictIs = {
+  empty: (m) => m.size === 0,
+  nonEmpty: (m) => m.size > 0
+};
+var empty = () => new globalThis.Map();
+var singleton = (key, value) => new globalThis.Map([[key, value]]);
+var DictFrom = {
+  entries: (entries3) => new globalThis.Map(entries3),
+  Record: (record) => new globalThis.Map(Object.entries(record)),
+  Array: (data) => new globalThis.Map(data),
+  nullable: (data) => data === null || data === void 0 ? Maybe.make.none() : Maybe.make.some(data)
+};
+var DictTo = {
+  Record: (map5) => {
+    const result = {};
+    for (const [k, v] of map5) {
+      result[k] = v;
     }
     return result;
-  };
-  Dict2.compact = (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (v.kind === "Some") {
-        result.set(k, v.value);
-      }
+  }
+};
+var groupBy2 = (f) => (as) => {
+  const result = new globalThis.Map();
+  for (const a of as) {
+    const k = f(a);
+    const existing = result.get(k);
+    if (existing !== void 0) {
+      existing.push(a);
+    } else {
+      result.set(k, [a]);
     }
-    return result;
-  };
-  Dict2.filterMap = (f) => (m) => {
-    const result = new globalThis.Map();
-    for (const [key, value] of m) {
-      const mapped = f(value);
-      if (mapped.kind === "Some") {
-        result.set(key, mapped.value);
-      }
+  }
+  return result;
+};
+var has = (key) => (data) => data.has(key);
+var lookup = (key) => (data) => {
+  const val = data.get(key);
+  return val !== void 0 || data.has(key) ? Maybe.make.some(val) : Maybe.make.none();
+};
+var size2 = (data) => data.size;
+var keys = (data) => Array.from(data.keys());
+var values = (data) => Array.from(data.values());
+var entries = (data) => Array.from(data.entries());
+var insert = (key, value) => (data) => {
+  const res = new globalThis.Map(data);
+  res.set(key, value);
+  return res;
+};
+var remove = (key) => (data) => {
+  if (!data.has(key)) {
+    return data;
+  }
+  const res = new globalThis.Map(data);
+  res.delete(key);
+  return res;
+};
+var upsert = (key, f) => (data) => {
+  const res = new globalThis.Map(data);
+  const existing = data.has(key) ? Maybe.make.some(data.get(key)) : Maybe.make.none();
+  res.set(key, f(existing));
+  return res;
+};
+var map2 = (f) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    res.set(k, f(v));
+  }
+  return res;
+};
+var mapWithKey = (f) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    res.set(k, f(k, v));
+  }
+  return res;
+};
+var filter2 = (predicate) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    if (predicate(v)) {
+      res.set(k, v);
     }
-    return result;
-  };
-  Dict2.union = (other) => (m) => {
-    const result = new globalThis.Map(m);
-    for (const [k, v] of other) {
-      result.set(k, v);
+  }
+  return res;
+};
+var filterWithKey = (predicate) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    if (predicate(k, v)) {
+      res.set(k, v);
     }
-    return result;
-  };
-  Dict2.intersection = (other) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (other.has(k)) {
-        result.set(k, v);
-      }
+  }
+  return res;
+};
+var compact2 = (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    if (v.kind === "Some") {
+      res.set(k, v.value);
     }
-    return result;
-  };
-  Dict2.difference = (other) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (!other.has(k)) {
-        result.set(k, v);
-      }
+  }
+  return res;
+};
+var filterMap2 = (f) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    const mb = f(v);
+    if (mb.kind === "Some") {
+      res.set(k, mb.value);
     }
-    return result;
-  };
-  Dict2.reduce = (init, f) => (m) => {
-    let acc = init;
-    for (const v of m.values()) {
-      acc = f(acc, v);
+  }
+  return res;
+};
+var union = (other) => (data) => {
+  if (data.size === 0) {
+    return other;
+  }
+  if (other.size === 0) {
+    return data;
+  }
+  const res = new globalThis.Map(data);
+  for (const [k, v] of other) {
+    res.set(k, v);
+  }
+  return res;
+};
+var intersection = (other) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    if (other.has(k)) {
+      res.set(k, v);
     }
-    return acc;
-  };
-  Dict2.reduceWithKey = (init, f) => (m) => {
-    let acc = init;
-    for (const [k, v] of m) {
-      acc = f(acc, v, k);
+  }
+  return res;
+};
+var difference = (other) => (data) => {
+  if (other.size === 0) {
+    return data;
+  }
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    if (!other.has(k)) {
+      res.set(k, v);
     }
-    return acc;
-  };
-  function mergeWith(combine) {
-    return (arg1, arg2) => {
-      if (arg2 !== void 0) {
-        const first = arg1;
-        const second2 = arg2;
-        const res = new globalThis.Map(first);
-        for (const [k, v] of second2) {
-          if (res.has(k)) {
-            res.set(k, combine(res.get(k), v));
-          } else {
-            res.set(k, v);
-          }
+  }
+  return res;
+};
+var reduce2 = (init2, f) => (data) => {
+  let acc = init2;
+  for (const [, v] of data) {
+    acc = f(acc, v);
+  }
+  return acc;
+};
+var reduceWithKey = (init2, f) => (data) => {
+  let acc = init2;
+  for (const [k, v] of data) {
+    acc = f(acc, v, k);
+  }
+  return acc;
+};
+function mergeWith(combine) {
+  return ((arg1, arg2) => {
+    if (arg2 !== void 0) {
+      const res = new globalThis.Map(arg1);
+      for (const [k, v] of arg2) {
+        if (res.has(k)) {
+          res.set(k, combine(res.get(k), v));
+        } else {
+          res.set(k, v);
         }
-        return res;
       }
+      return res;
+    }
+    return (first) => {
       const second = arg1;
-      return (first) => {
-        const res = new globalThis.Map(first);
-        for (const [k, v] of second) {
-          if (res.has(k)) {
-            res.set(k, combine(res.get(k), v));
-          } else {
-            res.set(k, v);
-          }
+      const res = new globalThis.Map(first);
+      for (const [k, v] of second) {
+        if (res.has(k)) {
+          res.set(k, combine(res.get(k), v));
+        } else {
+          res.set(k, v);
         }
-        return res;
-      };
+      }
+      return res;
     };
+  });
+}
+var mapEntries = (f) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    const [nk, nv] = f(k, v);
+    res.set(nk, nv);
   }
-  Dict2.mergeWith = mergeWith;
-  let to;
-  ((to2) => {
-    to2.Record = (m) => Object.fromEntries(m);
-  })(to = Dict2.to || (Dict2.to = {}));
-  Dict2.mapEntries = (f) => (data) => {
-    const res = new globalThis.Map();
-    for (const [k, v] of data) {
-      const [nk, nv] = f(k, v);
-      res.set(nk, nv);
-    }
-    return res;
-  };
-  Dict2.mapKeys = (f) => (data) => {
-    const res = new globalThis.Map();
-    for (const [k, v] of data) {
-      res.set(f(k), v);
-    }
-    return res;
-  };
-  Dict2.NonEmpty = DictNonEmpty;
-})(Dict || (Dict = {}));
+  return res;
+};
+var mapKeys = (f) => (data) => {
+  const res = new globalThis.Map();
+  for (const [k, v] of data) {
+    res.set(f(k), v);
+  }
+  return res;
+};
+var _nonEmptySingleton = (key, value) => new globalThis.Map([[key, value]]);
+var _nonEmptyFromMap = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
+var _nonEmptyKeys = (m) => keys(m);
+var _nonEmptyValues = (m) => values(m);
+var _nonEmptyEntries = (m) => entries(m);
+var _nonEmptyReduce = (f) => (m) => _nonEmptyValues(m).reduce(f);
+var _nonEmptyMap = (f) => (m) => map2(f)(m);
+var _nonEmptyMapWithKey = (f) => (m) => mapWithKey(f)(m);
+var DictNonEmptyConst = {
+  singleton: _nonEmptySingleton,
+  from: { Map: _nonEmptyFromMap },
+  keys: _nonEmptyKeys,
+  values: _nonEmptyValues,
+  entries: _nonEmptyEntries,
+  reduce: _nonEmptyReduce,
+  map: _nonEmptyMap,
+  mapWithKey: _nonEmptyMapWithKey
+};
+var Dict = {
+  is: DictIs,
+  empty,
+  singleton,
+  from: DictFrom,
+  to: DictTo,
+  groupBy: groupBy2,
+  has,
+  lookup,
+  size: size2,
+  keys,
+  values,
+  entries,
+  insert,
+  remove,
+  upsert,
+  map: map2,
+  mapWithKey,
+  filter: filter2,
+  filterWithKey,
+  compact: compact2,
+  filterMap: filterMap2,
+  union,
+  intersection,
+  difference,
+  reduce: reduce2,
+  reduceWithKey,
+  mergeWith,
+  mapEntries,
+  mapKeys,
+  NonEmpty: DictNonEmptyConst
+};
 
 // src/Data/Json.ts
 var isSyntaxError = (err) => typeof err === "object" && err !== null && "name" in err && err.name === "SyntaxError";
 var isTypeError = (err) => typeof err === "object" && err !== null && "name" in err && err.name === "TypeError";
-var Json;
-((Json2) => {
-  Json2.parse = (text) => Result.tryCatch(() => JSON.parse(text), {
+var 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) => Result.tryCatch(() => JSON.parse(text), {
     onError: (err) => isSyntaxError(err) ? err : new SyntaxError(String(err))
-  });
-  Json2.stringify = (value, replacer, space) => Result.tryCatch(() => JSON.stringify(value, replacer, space), {
+  }),
+  /**
+   * 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, replacer, space) => Result.tryCatch(() => JSON.stringify(value, replacer, space), {
     onError: (err) => isTypeError(err) ? err : new TypeError(String(err))
-  });
-})(Json || (Json = {}));
+  })
+};
 
 // src/Data/Num.ts
-var Num;
-((Num2) => {
-  let is;
-  ((is2) => {
-    is2.zero = (n) => n === 0;
-    is2.integer = (n) => Number.isInteger(n);
-    is2.float = (n) => Number.isFinite(n) && !Number.isInteger(n);
-    is2.finite = (n) => Number.isFinite(n);
-    is2.nan = (n) => Number.isNaN(n);
-    is2.even = (n) => Number.isInteger(n) && n % 2 === 0;
-    is2.odd = (n) => Number.isInteger(n) && n % 2 !== 0;
-    is2.positive = (n) => n > 0;
-    is2.negative = (n) => n < 0;
-  })(is = Num2.is || (Num2.is = {}));
-  Num2.range = (from, to, step = 1) => {
+var sumFn = (ns) => {
+  let result = 0;
+  for (let i = 0; i < ns.length; i++) {
+    result += ns[i];
+  }
+  return result;
+};
+var 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) => n === 0,
+    /**
+     * 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.isInteger(n),
+    /**
+     * 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.isFinite(n) && !Number.isInteger(n),
+    /**
+     * 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.isFinite(n),
+    /**
+     * Returns `true` when the value is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Num.is.nan(NaN); // true
+     * Num.is.nan(42);  // false
+     * ```
+     */
+    nan: (n) => Number.isNaN(n),
+    /**
+     * 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.isInteger(n) && n % 2 === 0,
+    /**
+     * 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.isInteger(n) && n % 2 !== 0,
+    /**
+     * 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) => n > 0,
+    /**
+     * 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) => n < 0
+  },
+  /**
+   * 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, to, step = 1) => {
     if (step <= 0 || from > to) {
       return [];
     }
@@ -1039,36 +2281,191 @@ var Num;
       result[i] = from + i * step;
     }
     return result;
-  };
-  Num2.clamp = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
-  Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
-  Num2.inRange = (start, end) => (n) => n >= start && n < end;
-  Num2.parse = (s) => {
+  },
+  /**
+   * 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, max) => (n) => Math.min(Math.max(n, min), max),
+  /**
+   * 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, max) => (n) => n >= min && n <= max,
+  /**
+   * 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, end) => (n) => n >= start && n < end,
+  /**
+   * 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) => {
     if (s.trim() === "") {
       return Maybe.make.none();
     }
     const n = Number(s);
     return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-  };
-  Num2.add = (b) => (a) => a + b;
-  Num2.subtract = (b) => (a) => a - b;
-  Num2.multiply = (b) => (a) => a * b;
-  Num2.divide = (b) => (a) => b === 0 ? Maybe.make.none() : Maybe.make.some(a / b);
-  Num2.abs = (n) => Math.abs(n);
-  Num2.negate = (n) => -n;
-  Num2.round = (n) => Math.round(n);
-  Num2.floor = (n) => Math.floor(n);
-  Num2.ceil = (n) => Math.ceil(n);
-  Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(n % divisor);
-  Num2.sum = (ns) => {
-    let result = 0;
-    for (let i = 0; i < ns.length; i++) {
-      result += ns[i];
-    }
-    return result;
-  };
-  Num2.mean = (ns) => ns.length === 0 ? Maybe.make.none() : Maybe.make.some((0, Num2.sum)(ns) / ns.length);
-  Num2.min = (ns) => {
+  },
+  /**
+   * 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) => (a) => a + b,
+  /**
+   * 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) => (a) => a - b,
+  /**
+   * 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) => (a) => a * b,
+  /**
+   * 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) => (a) => b === 0 ? Maybe.make.none() : Maybe.make.some(a / b),
+  /**
+   * Returns the absolute value of a number.
+   *
+   * @example
+   * ```ts
+   * pipe(-5, Num.abs); // 5
+   * pipe(5, Num.abs);  // 5
+   * ```
+   */
+  abs: (n) => Math.abs(n),
+  /**
+   * Negates a number (arithmetic negation).
+   *
+   * @example
+   * ```ts
+   * pipe(5, Num.negate);  // -5
+   * pipe(-5, Num.negate); // 5
+   * ```
+   */
+  negate: (n) => -n,
+  /**
+   * Rounds a number to the nearest integer.
+   *
+   * @example
+   * ```ts
+   * pipe(3.5, Num.round); // 4
+   * pipe(3.4, Num.round); // 3
+   * ```
+   */
+  round: (n) => Math.round(n),
+  /**
+   * Rounds a number down to the nearest integer.
+   *
+   * @example
+   * ```ts
+   * pipe(3.9, Num.floor); // 3
+   * pipe(-3.2, Num.floor); // -4
+   * ```
+   */
+  floor: (n) => Math.floor(n),
+  /**
+   * Rounds a number up to the nearest integer.
+   *
+   * @example
+   * ```ts
+   * pipe(3.1, Num.ceil); // 4
+   * pipe(-3.9, Num.ceil); // -3
+   * ```
+   */
+  ceil: (n) => Math.ceil(n),
+  /**
+   * 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) => (n) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(n % divisor),
+  /**
+   * 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: sumFn,
+  /**
+   * 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) => ns.length === 0 ? Maybe.make.none() : Maybe.make.some(sumFn(ns) / ns.length),
+  /**
+   * 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) => {
     if (ns.length === 0) {
       return Maybe.make.none();
     }
@@ -1079,8 +2476,17 @@ var Num;
       }
     }
     return Maybe.make.some(result);
-  };
-  Num2.max = (ns) => {
+  },
+  /**
+   * 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) => {
     if (ns.length === 0) {
       return Maybe.make.none();
     }
@@ -1091,9 +2497,20 @@ var Num;
       }
     }
     return Maybe.make.some(result);
-  };
-  Num2.format = (options, locales) => (n) => !Number.isFinite(n) ? Maybe.make.none() : Maybe.make.some(new Intl.NumberFormat(locales, options).format(n));
-})(Num || (Num = {}));
+  },
+  /**
+   * 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, locales) => (n) => !Number.isFinite(n) ? Maybe.make.none() : Maybe.make.some(new Intl.NumberFormat(locales, options).format(n))
+};
 
 // src/Data/Rec.ts
 var _isNonEmpty = (data) => Object.keys(data).length > 0;
@@ -1141,259 +2558,466 @@ var RecResult;
   };
   RecResult2.sequence = (data) => (0, RecResult2.traverse)((a) => a)(data);
 })(RecResult || (RecResult = {}));
-var RecNonEmpty;
-((RecNonEmpty2) => {
-  RecNonEmpty2.singleton = (key, value) => ({ [key]: value });
-  let from;
-  ((from2) => {
-    from2.Record = (data) => _isNonEmpty(data) ? Maybe.make.some(data) : Maybe.make.none();
-  })(from = RecNonEmpty2.from || (RecNonEmpty2.from = {}));
-  RecNonEmpty2.keys = (data) => Rec.keys(data);
-  RecNonEmpty2.values = (data) => Rec.values(data);
-  RecNonEmpty2.entries = (data) => Rec.entries(data);
-  RecNonEmpty2.reduce = (f) => (data) => (0, RecNonEmpty2.values)(data).reduce(f);
-  RecNonEmpty2.map = (f) => (data) => Rec.map(f)(data);
-  RecNonEmpty2.mapWithKey = (f) => (data) => Rec.mapWithKey(f)(data);
-})(RecNonEmpty || (RecNonEmpty = {}));
-var Rec;
-((Rec2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (data) => Object.keys(data).length === 0;
-    is2.nonEmpty = _isNonEmpty;
-  })(is = Rec2.is || (Rec2.is = {}));
-  Rec2.map = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      const key = recordKeys[i];
-      if (key === "__proto__") {
-        Object.defineProperty(result, "__proto__", {
-          value: f(recordValues[i]),
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      } else {
-        result[key] = f(recordValues[i]);
-      }
-    }
-    return result;
-  };
-  Rec2.filterMap = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      const maybeVal = f(recordValues[i]);
-      if (maybeVal.kind === "Some") {
-        _setKey(result, recordKeys[i], maybeVal.value);
-      }
+var RecIs = {
+  /**
+   * Returns true if the record has no keys.
+   *
+   * @example
+   * ```ts
+   * Rec.is.empty({});       // true
+   * Rec.is.empty({ a: 1 }); // false
+   * ```
+   */
+  empty: (data) => Object.keys(data).length === 0,
+  /**
+   * Type guard to check if a record is non-empty.
+   *
+   * @example
+   * ```ts
+   * Rec.is.nonEmpty({ a: 1 }); // true
+   * Rec.is.nonEmpty({});       // false
+   * ```
+   */
+  nonEmpty: _isNonEmpty
+};
+var map3 = (f) => (data) => {
+  const recordKeys = Object.keys(data);
+  const recordValues = Object.values(data);
+  const result = Object.create(Object.getPrototypeOf(data));
+  for (let i = 0; i < recordKeys.length; i++) {
+    const key = recordKeys[i];
+    if (key === "__proto__") {
+      Object.defineProperty(result, "__proto__", {
+        value: f(recordValues[i]),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    } else {
+      result[key] = f(recordValues[i]);
     }
-    return result;
-  };
-  Rec2.mapWithKey = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      const key = recordKeys[i];
-      _setKey(result, key, f(key, recordValues[i]));
+  }
+  return result;
+};
+var filterMap3 = (f) => (data) => {
+  const recordKeys = Object.keys(data);
+  const recordValues = Object.values(data);
+  const result = Object.create(Object.getPrototypeOf(data));
+  for (let i = 0; i < recordKeys.length; i++) {
+    const maybeVal = f(recordValues[i]);
+    if (maybeVal.kind === "Some") {
+      _setKey(result, recordKeys[i], maybeVal.value);
     }
-    return result;
-  };
-  Rec2.filter = (predicate) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      if (predicate(recordValues[i])) {
-        _setKey(result, recordKeys[i], recordValues[i]);
-      }
+  }
+  return result;
+};
+var mapWithKey2 = (f) => (data) => {
+  const recordKeys = Object.keys(data);
+  const recordValues = Object.values(data);
+  const result = Object.create(Object.getPrototypeOf(data));
+  for (let i = 0; i < recordKeys.length; i++) {
+    const key = recordKeys[i];
+    _setKey(result, key, f(key, recordValues[i]));
+  }
+  return result;
+};
+var filter3 = (predicate) => (data) => {
+  const recordKeys = Object.keys(data);
+  const recordValues = Object.values(data);
+  const result = Object.create(Object.getPrototypeOf(data));
+  for (let i = 0; i < recordKeys.length; i++) {
+    if (predicate(recordValues[i])) {
+      _setKey(result, recordKeys[i], recordValues[i]);
     }
-    return result;
-  };
-  Rec2.filterWithKey = (predicate) => (data) => {
-    const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      if (predicate(k, v)) {
-        _setKey(result, k, v);
-      }
+  }
+  return result;
+};
+var filterWithKey2 = (predicate) => (data) => {
+  const result = {};
+  for (const [k, v] of Object.entries(data)) {
+    if (predicate(k, v)) {
+      _setKey(result, k, v);
     }
-    return result;
-  };
-  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? { kind: "Some", value: data[key] } : { kind: "None" };
-  Rec2.keys = (data) => Object.keys(data);
-  Rec2.values = (data) => Object.values(data);
-  Rec2.entries = (data) => Object.entries(data);
-  let from;
-  ((from2) => {
-    from2.entries = (data) => Object.fromEntries(data);
-  })(from = Rec2.from || (Rec2.from = {}));
-  Rec2.groupBy = (keyFn) => (items) => {
-    const result = {};
-    for (const item of items) {
-      const key = keyFn(item);
-      if (Object.hasOwn(result, key)) {
-        result[key].push(item);
-      } else {
-        _setKey(result, key, [item]);
-      }
+  }
+  return result;
+};
+var lookup2 = (key) => (data) => Object.hasOwn(data, key) ? { kind: "Some", value: data[key] } : { kind: "None" };
+var keys2 = (data) => Object.keys(data);
+var values2 = (data) => Object.values(data);
+var entries2 = (data) => Object.entries(data);
+var RecFrom = {
+  /**
+   * Creates a record from key-value pairs.
+   *
+   * @example
+   * ```ts
+   * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
+   * ```
+   */
+  entries: (data) => Object.fromEntries(data)
+};
+var groupBy3 = (keyFn) => (items) => {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (Object.hasOwn(result, key)) {
+      result[key].push(item);
+    } else {
+      _setKey(result, key, [item]);
     }
-    return result;
-  };
-  Rec2.pick = (...pickedKeys) => (data) => {
-    const result = {};
-    for (const key of pickedKeys) {
-      if (Object.hasOwn(data, key)) {
-        _setKey(result, key, data[key]);
-      }
+  }
+  return result;
+};
+var pick = (...pickedKeys) => (data) => {
+  const result = {};
+  for (const key of pickedKeys) {
+    if (Object.hasOwn(data, key)) {
+      _setKey(result, key, data[key]);
     }
-    return result;
-  };
-  Rec2.omit = (...omittedKeys) => (data) => {
-    const omitSet = new Set(omittedKeys);
-    const result = {};
-    for (const key of Object.keys(data)) {
-      if (!omitSet.has(key)) {
-        _setKey(result, key, data[key]);
-      }
+  }
+  return result;
+};
+var omit = (...omittedKeys) => (data) => {
+  const omitSet = new Set(omittedKeys);
+  const result = {};
+  for (const key of Object.keys(data)) {
+    if (!omitSet.has(key)) {
+      _setKey(result, key, data[key]);
     }
-    return result;
-  };
-  Rec2.merge = (other) => (data) => ({
-    ...data,
-    ...other
-  });
-  function mergeWith(combine) {
-    return (arg1, arg2) => {
-      if (arg2 !== void 0) {
-        const first = arg1;
-        const second2 = arg2;
-        const result = { ...first };
-        for (const [k, v] of Object.entries(second2)) {
-          if (Object.hasOwn(result, k)) {
-            result[k] = combine(result[k], v);
-          } else {
-            result[k] = v;
-          }
+  }
+  return result;
+};
+var merge = (other) => (data) => ({
+  ...data,
+  ...other
+});
+function mergeWith2(combine) {
+  return (arg1, arg2) => {
+    if (arg2 !== void 0) {
+      const first = arg1;
+      const second2 = arg2;
+      const result = { ...first };
+      for (const [k, v] of Object.entries(second2)) {
+        if (Object.hasOwn(result, k)) {
+          result[k] = combine(result[k], v);
+        } else {
+          result[k] = v;
         }
-        return result;
       }
-      const second = arg1;
-      return (first) => {
-        const result = { ...first };
-        for (const [k, v] of Object.entries(second)) {
-          if (Object.hasOwn(result, k)) {
-            result[k] = combine(result[k], v);
-          } else {
-            result[k] = v;
-          }
+      return result;
+    }
+    const second = arg1;
+    return (first) => {
+      const result = { ...first };
+      for (const [k, v] of Object.entries(second)) {
+        if (Object.hasOwn(result, k)) {
+          result[k] = combine(result[k], v);
+        } else {
+          result[k] = v;
         }
-        return result;
-      };
-    };
-  }
-  Rec2.mergeWith = mergeWith;
-  Rec2.size = (data) => Object.keys(data).length;
-  Rec2.mapKeys = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    if (keys2.length === 0) {
-      return data;
-    }
-    const result = {};
-    for (let i = 0; i < keys2.length; i++) {
-      const k = keys2[i];
-      _setKey(result, f(k), data[k]);
-    }
-    return result;
-  };
-  Rec2.compact = (data) => {
-    const keys2 = Object.keys(data);
-    if (keys2.length === 0) {
-      return {};
-    }
-    const result = {};
-    for (let i = 0; i < keys2.length; i++) {
-      const k = keys2[i];
-      const v = data[k];
-      if (v.kind === "Some") {
-        _setKey(result, k, v.value);
       }
-    }
-    return result;
+      return result;
+    };
   };
-  Rec2.mapEntries = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    if (keys2.length === 0) {
-      return {};
+}
+var size3 = (data) => Object.keys(data).length;
+var mapKeys2 = (f) => (data) => {
+  const recKeys = Object.keys(data);
+  if (recKeys.length === 0) {
+    return data;
+  }
+  const result = {};
+  for (let i = 0; i < recKeys.length; i++) {
+    const k = recKeys[i];
+    _setKey(result, f(k), data[k]);
+  }
+  return result;
+};
+var compact3 = (data) => {
+  const recKeys = Object.keys(data);
+  if (recKeys.length === 0) {
+    return {};
+  }
+  const result = {};
+  for (let i = 0; i < recKeys.length; i++) {
+    const k = recKeys[i];
+    const v = data[k];
+    if (v.kind === "Some") {
+      _setKey(result, k, v.value);
     }
-    const result = {};
-    for (let i = 0; i < keys2.length; i++) {
-      const k = keys2[i];
-      const [newKey, newVal] = f(k, data[k]);
-      _setKey(result, newKey, newVal);
+  }
+  return result;
+};
+var mapEntries2 = (f) => (data) => {
+  const recKeys = Object.keys(data);
+  if (recKeys.length === 0) {
+    return {};
+  }
+  const result = {};
+  for (let i = 0; i < recKeys.length; i++) {
+    const k = recKeys[i];
+    const [newKey, newVal] = f(k, data[k]);
+    _setKey(result, newKey, newVal);
+  }
+  return result;
+};
+var updateIn = (path, f) => (data) => {
+  const updateNode = (obj, pathKeys) => {
+    const [head2, ...tail2] = pathKeys;
+    if (tail2.length === 0) {
+      return { ...obj, [head2]: f(obj?.[head2]) };
     }
-    return result;
+    const child = obj && typeof obj === "object" && head2 in obj ? obj[head2] : {};
+    return { ...obj, [head2]: updateNode(child, tail2) };
   };
-  Rec2.updateIn = (path, f) => (data) => {
-    const updateNode = (obj, keys2) => {
-      const [head, ...tail] = keys2;
-      if (tail.length === 0) {
-        return { ...obj, [head]: f(obj?.[head]) };
-      }
-      const child = obj && typeof obj === "object" && head in obj ? obj[head] : {};
-      return { ...obj, [head]: updateNode(child, tail) };
-    };
-    return updateNode(data, path);
-  };
-  let traverse;
-  ((traverse2) => {
-    traverse2.Maybe = RecMaybe.traverse;
-    traverse2.Result = RecResult.traverse;
-  })(traverse = Rec2.traverse || (Rec2.traverse = {}));
-  let sequence;
-  ((sequence2) => {
-    sequence2.Maybe = RecMaybe.sequence;
-    sequence2.Result = RecResult.sequence;
-  })(sequence = Rec2.sequence || (Rec2.sequence = {}));
-  Rec2.NonEmpty = RecNonEmpty;
-})(Rec || (Rec = {}));
+  return updateNode(data, path);
+};
+var RecTo = {
+  Dict: (data) => new globalThis.Map(Object.entries(data))
+};
+var RecNonEmpty = {
+  singleton: (key, value) => ({ [key]: value }),
+  from: {
+    Record: (data) => _isNonEmpty(data) ? Maybe.make.some(data) : Maybe.make.none()
+  },
+  keys: (data) => keys2(data),
+  values: (data) => values2(data),
+  entries: (data) => entries2(data),
+  reduce: (f) => (data) => values2(data).reduce(f),
+  map: (f) => (data) => map3(f)(data),
+  mapWithKey: (f) => (data) => mapWithKey2(f)(data)
+};
+var Rec = {
+  is: RecIs,
+  from: RecFrom,
+  to: RecTo,
+  map: map3,
+  filterMap: filterMap3,
+  mapWithKey: mapWithKey2,
+  filter: filter3,
+  filterWithKey: filterWithKey2,
+  lookup: lookup2,
+  keys: keys2,
+  values: values2,
+  entries: entries2,
+  groupBy: groupBy3,
+  pick,
+  omit,
+  merge,
+  mergeWith: mergeWith2,
+  size: size3,
+  mapKeys: mapKeys2,
+  compact: compact3,
+  mapEntries: mapEntries2,
+  updateIn,
+  traverse: { Maybe: RecMaybe.traverse, Result: RecResult.traverse },
+  sequence: { Maybe: RecMaybe.sequence, Result: RecResult.sequence },
+  NonEmpty: RecNonEmpty
+};
 
 // src/Data/Str.ts
-var StrNonEmpty;
-((StrNonEmpty2) => {
-  let from;
-  ((from2) => {
-    from2.String = (s) => s.length > 0 ? Maybe.make.some(s) : Maybe.make.none();
-  })(from = StrNonEmpty2.from || (StrNonEmpty2.from = {}));
-})(StrNonEmpty || (StrNonEmpty = {}));
-var Str;
-((Str2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (s) => s.length === 0;
-    is2.nonEmpty = (s) => s.length > 0;
-  })(is = Str2.is || (Str2.is = {}));
-  Str2.split = (separator) => (s) => s.split(separator);
-  Str2.trim = (s) => s.trim();
-  Str2.includes = (substring) => (s) => s.includes(substring);
-  Str2.replace = (pattern, replacement) => (s) => s.replace(pattern, replacement);
-  Str2.replaceAll = (pattern, replacement) => (s) => s.replaceAll(pattern, replacement);
-  Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
-  Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
-  Str2.toUpperCase = (s) => s.toUpperCase();
-  Str2.toLowerCase = (s) => s.toLowerCase();
-  Str2.capitalize = (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1);
-  Str2.lines = (s) => s.split(/\r?\n|\r/);
-  Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
-  Str2.isBlank = (s) => s.trim().length === 0;
-  Str2.length = (s) => s.length;
-  Str2.slice = (start, end) => (s) => s.slice(start, end);
-  Str2.padStart = (maxLength, fillString) => (s) => s.padStart(maxLength, fillString);
-  Str2.padEnd = (maxLength, fillString) => (s) => s.padEnd(maxLength, fillString);
-  Str2.parse = {
+var StrNonEmptyConst = {
+  // --- from ---
+  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) => s.length > 0 ? Maybe.make.some(s) : Maybe.make.none()
+  }
+};
+var isEmpty = (s) => s.length === 0;
+var isNonEmpty = (s) => s.length > 0;
+var Str = {
+  is: {
+    /**
+     * Returns `true` when the string is empty.
+     *
+     * @example
+     * ```ts
+     * pipe("", Str.is.empty);   // true
+     * pipe("hi", Str.is.empty); // false
+     * ```
+     */
+    empty: isEmpty,
+    /**
+     * Type guard to check if a string is non-empty.
+     */
+    nonEmpty: isNonEmpty
+  },
+  /**
+   * Splits a string by a separator. Data-last: use in `pipe`.
+   *
+   * @example
+   * ```ts
+   * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
+   * ```
+   */
+  split: (separator) => (s) => s.split(separator),
+  /**
+   * Removes leading and trailing whitespace from a string.
+   *
+   * @example
+   * ```ts
+   * pipe("  hello  ", Str.trim); // "hello"
+   * ```
+   */
+  trim: (s) => s.trim(),
+  /**
+   * 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) => (s) => s.includes(substring),
+  /**
+   * 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, replacement) => (s) => s.replace(pattern, replacement),
+  /**
+   * 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, replacement) => (s) => s.replaceAll(pattern, replacement),
+  /**
+   * 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) => (s) => s.startsWith(prefix),
+  /**
+   * 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) => (s) => s.endsWith(suffix),
+  /**
+   * Converts a string to uppercase.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.toUpperCase); // "HELLO"
+   * ```
+   */
+  toUpperCase: (s) => s.toUpperCase(),
+  /**
+   * Converts a string to lowercase.
+   *
+   * @example
+   * ```ts
+   * pipe("HELLO", Str.toLowerCase); // "hello"
+   * ```
+   */
+  toLowerCase: (s) => s.toLowerCase(),
+  /**
+   * Converts the first character of a string to uppercase.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.capitalize); // "Hello"
+   * ```
+   */
+  capitalize: (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1),
+  /**
+   * 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) => s.split(/\r?\n|\r/),
+  /**
+   * Splits a string into words on any whitespace boundary, filtering out empty strings.
+   *
+   * @example
+   * ```ts
+   * Str.words("  hello   world  "); // ["hello", "world"]
+   * ```
+   */
+  words: (s) => s.trim().split(/\s+/).filter(Boolean),
+  /**
+   * Returns `true` when the string is empty or contains only whitespace.
+   *
+   * @example
+   * ```ts
+   * pipe("   ", Str.isBlank); // true
+   * pipe("hi", Str.isBlank);  // false
+   * ```
+   */
+  isBlank: (s) => s.trim().length === 0,
+  /**
+   * Returns the length of the string.
+   *
+   * @example
+   * ```ts
+   * pipe("hello", Str.length); // 5
+   * pipe("", Str.length);      // 0
+   * ```
+   */
+  length: (s) => s.length,
+  /**
+   * 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, end) => (s) => s.slice(start, end),
+  /**
+   * 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, fillString) => (s) => s.padStart(maxLength, fillString),
+  /**
+   * 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, fillString) => (s) => s.padEnd(maxLength, fillString),
+  /**
+   * 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`.
      *
@@ -1428,16 +3052,45 @@ var Str;
       const n = Number.parseFloat(s);
       return Number.isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
     }
-  };
-  Str2.parseJson = (s) => {
+  },
+  /**
+   * 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) => {
     try {
       return Result.make.ok(JSON.parse(s));
     } catch (error) {
       return Result.make.err(error);
     }
-  };
-  Str2.uncapitalize = (s) => s.length === 0 ? "" : s.charAt(0).toLowerCase() + s.slice(1);
-  Str2.truncate = (options) => (s) => {
+  },
+  /**
+   * Converts the first character of a string to lower case.
+   *
+   * @example
+   * ```ts
+   * Str.uncapitalize("Hello"); // "hello"
+   * Str.uncapitalize("");      // ""
+   * ```
+   */
+  uncapitalize: (s) => s.length === 0 ? "" : s.charAt(0).toLowerCase() + s.slice(1),
+  /**
+   * 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) => (s) => {
     const { length: targetLength, suffix = "..." } = options;
     if (s.length <= targetLength) {
       return s;
@@ -1446,134 +3099,157 @@ var Str;
       return suffix.slice(0, targetLength);
     }
     return s.slice(0, targetLength - suffix.length) + suffix;
-  };
-  Str2.NonEmpty = StrNonEmpty;
-})(Str || (Str = {}));
+  },
+  NonEmpty: StrNonEmptyConst
+};
 
 // src/Data/Uniq.ts
-var UniqNonEmpty;
-((UniqNonEmpty2) => {
-  UniqNonEmpty2.singleton = (item) => new globalThis.Set([item]);
-  let from;
-  ((from2) => {
-    from2.Set = (s) => s.size > 0 ? Maybe.make.some(s) : Maybe.make.none();
-  })(from = UniqNonEmpty2.from || (UniqNonEmpty2.from = {}));
-  UniqNonEmpty2.reduce = (f) => (s) => to.Array(s).reduce(f);
-  UniqNonEmpty2.map = (f) => (s) => Uniq.map(f)(s);
-  let to;
-  ((to2) => {
-    to2.Array = (s) => Uniq.to.Array(s);
-  })(to = UniqNonEmpty2.to || (UniqNonEmpty2.to = {}));
-})(UniqNonEmpty || (UniqNonEmpty = {}));
-var Uniq;
-((Uniq2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (s) => s.size === 0;
-    is2.nonEmpty = (s) => s.size > 0;
-  })(is = Uniq2.is || (Uniq2.is = {}));
-  Uniq2.empty = () => new globalThis.Set();
-  Uniq2.singleton = (item) => new globalThis.Set([item]);
-  let from;
-  ((from2) => {
-    from2.Array = (arr) => new globalThis.Set(arr);
-  })(from = Uniq2.from || (Uniq2.from = {}));
-  Uniq2.has = (item) => (s) => s.has(item);
-  Uniq2.size = (s) => s.size;
-  Uniq2.isSubsetOf = (other) => (s) => {
-    const set = s;
-    if (typeof set.isSubsetOf === "function") {
-      return set.isSubsetOf(other);
-    }
-    for (const item of s) {
-      if (!other.has(item)) {
-        return false;
-      }
-    }
-    return true;
-  };
-  Uniq2.insert = (item) => (s) => {
-    if (s.has(item)) {
-      return s;
-    }
-    const result = new globalThis.Set(s);
-    result.add(item);
-    return result;
-  };
-  Uniq2.remove = (item) => (s) => {
-    if (!s.has(item)) {
-      return s;
-    }
-    const result = new globalThis.Set(s);
+var isEmpty2 = (s) => s.size === 0;
+var isNonEmpty2 = (s) => s.size > 0;
+var empty2 = () => new globalThis.Set();
+var singleton2 = (item) => new globalThis.Set([item]);
+var fromArray = (arr) => new globalThis.Set(arr);
+var has2 = (item) => (s) => s.has(item);
+var size4 = (s) => s.size;
+var add = (item) => (s) => {
+  if (s.has(item)) {
+    return s;
+  }
+  const result = new globalThis.Set(s);
+  result.add(item);
+  return result;
+};
+var remove2 = (item) => (s) => {
+  if (!s.has(item)) {
+    return s;
+  }
+  const result = new globalThis.Set(s);
+  result.delete(item);
+  return result;
+};
+var toggle = (item) => (s) => {
+  const result = new globalThis.Set(s);
+  if (result.has(item)) {
     result.delete(item);
-    return result;
-  };
-  Uniq2.map = (f) => (s) => {
-    const result = new globalThis.Set();
-    for (const item of s) {
-      result.add(f(item));
-    }
-    return result;
-  };
-  Uniq2.filter = (predicate) => (s) => {
-    const result = new globalThis.Set();
-    for (const item of s) {
-      if (predicate(item)) {
-        result.add(item);
-      }
+  } else {
+    result.add(item);
+  }
+  return result;
+};
+var map4 = (f) => (s) => {
+  const result = new globalThis.Set();
+  for (const item of s) {
+    result.add(f(item));
+  }
+  return result;
+};
+var filter4 = (predicate) => (s) => {
+  const result = new globalThis.Set();
+  for (const item of s) {
+    if (predicate(item)) {
+      result.add(item);
     }
-    return result;
-  };
-  Uniq2.union = (other) => (s) => {
-    const set = s;
-    if (typeof set.union === "function") {
-      return set.union(other);
+  }
+  return result;
+};
+var filterMap4 = (f) => (s) => {
+  const result = new globalThis.Set();
+  for (const item of s) {
+    const mb = f(item);
+    if (mb.kind === "Some") {
+      result.add(mb.value);
     }
-    const result = new globalThis.Set(s);
-    for (const item of other) {
+  }
+  return result;
+};
+var union2 = (other) => (s) => {
+  const set = s;
+  if (typeof set.union === "function") {
+    return set.union(other);
+  }
+  const result = new globalThis.Set(s);
+  for (const item of other) {
+    result.add(item);
+  }
+  return result;
+};
+var intersection2 = (other) => (s) => {
+  const set = s;
+  if (typeof set.intersection === "function") {
+    return set.intersection(other);
+  }
+  const result = new globalThis.Set();
+  for (const item of s) {
+    if (other.has(item)) {
       result.add(item);
     }
-    return result;
-  };
-  Uniq2.intersection = (other) => (s) => {
-    const set = s;
-    if (typeof set.intersection === "function") {
-      return set.intersection(other);
-    }
-    const result = new globalThis.Set();
-    for (const item of s) {
-      if (other.has(item)) {
-        result.add(item);
-      }
-    }
-    return result;
-  };
-  Uniq2.difference = (other) => (s) => {
-    const set = s;
-    if (typeof set.difference === "function") {
-      return set.difference(other);
-    }
-    const result = new globalThis.Set();
-    for (const item of s) {
-      if (!other.has(item)) {
-        result.add(item);
-      }
+  }
+  return result;
+};
+var difference2 = (other) => (s) => {
+  const set = s;
+  if (typeof set.difference === "function") {
+    return set.difference(other);
+  }
+  const result = new globalThis.Set();
+  for (const item of s) {
+    if (!other.has(item)) {
+      result.add(item);
     }
-    return result;
-  };
-  Uniq2.reduce = (init, f) => (s) => {
-    let acc = init;
-    for (const item of s) {
-      acc = f(acc, item);
+  }
+  return result;
+};
+var isSubsetOf = (other) => (s) => {
+  const set = s;
+  if (typeof set.isSubsetOf === "function") {
+    return set.isSubsetOf(other);
+  }
+  for (const item of s) {
+    if (!other.has(item)) {
+      return false;
     }
-    return acc;
-  };
-  let to;
-  ((to2) => {
-    to2.Array = (s) => [...s];
-  })(to = Uniq2.to || (Uniq2.to = {}));
-  Uniq2.NonEmpty = UniqNonEmpty;
-})(Uniq || (Uniq = {}));
+  }
+  return true;
+};
+var reduce3 = (init2, f) => (s) => {
+  let acc = init2;
+  for (const item of s) {
+    acc = f(acc, item);
+  }
+  return acc;
+};
+var toArray = (s) => [...s];
+var UniqNonEmptyConst = {
+  singleton: (item) => new globalThis.Set([item]),
+  from: {
+    Set: (s) => s.size > 0 ? Maybe.make.some(s) : Maybe.make.none()
+  },
+  reduce: (f) => (s) => toArray(s).reduce(f),
+  map: (f) => (s) => map4(f)(s),
+  to: { Array: (s) => toArray(s) }
+};
+var Uniq = {
+  is: { empty: isEmpty2, nonEmpty: isNonEmpty2 },
+  empty: empty2,
+  singleton: singleton2,
+  from: { Array: fromArray },
+  has: has2,
+  size: size4,
+  add,
+  insert: add,
+  remove: remove2,
+  toggle,
+  map: map4,
+  filter: filter4,
+  filterMap: filterMap4,
+  union: union2,
+  intersection: intersection2,
+  difference: difference2,
+  isSubsetOf,
+  reduce: reduce3,
+  to: { Array: toArray },
+  NonEmpty: UniqNonEmptyConst
+};
 export {
   Arr,
   BigNum,