@nlozgachev/pipelined 0.40.0 → 0.41.0

package/dist/composition.d.ts

@@ -1,3 +1,5 @@
+import { D as Duration } from './Duration-BTeT9D-q.js';
+
 /**
  * Composes functions from right to left, returning a new function.
  * This is the traditional mathematical function composition: (f . g)(x) = f(g(x))
@@ -617,7 +619,132 @@ interface pipe {
  *
  * @see {@link Maybe.tap} for Maybe-specific tap that only runs on Some
  */
-declare const tap: <A>(f: (a: A) => void) => (a: A) => A;
+declare function tap<A>(f: (a: A) => void): (a: A) => A;
+declare namespace tap {
+    /**
+     * Configuration options for {@link tap.log}.
+     */
+    type LogOptions<A> = {
+        /**
+         * An optional label prefix for the log output (e.g., `[label]: value`).
+         */
+        readonly label?: string;
+        /**
+         * The logging destination function. Defaults to `console.log`.
+         */
+        readonly logger?: (message: string) => void;
+        /**
+         * A custom formatter function to convert the piped value to a string.
+         * Defaults to `JSON.stringify` for objects and `String(value)` for primitives.
+         */
+        readonly formatter?: (value: A) => string;
+    };
+    /**
+     * Configuration options for {@link tap.inspect}.
+     */
+    type InspectOptions = {
+        /**
+         * An optional label prefix for the inspect output (e.g., `[label]: value`).
+         */
+        readonly label?: string;
+        /**
+         * The maximum depth to recurse when formatting the object.
+         * Defaults to `null` (infinite depth).
+         */
+        readonly depth?: number;
+        /**
+         * Whether to colorize the output using ANSI color codes.
+         * Defaults to `true`.
+         */
+        readonly colors?: boolean;
+    };
+    /**
+     * Configuration options for {@link tap.async}.
+     */
+    type AsyncOptions = {
+        /**
+         * A callback to handle exceptions thrown by the async side-effect.
+         * Defaults to logging via `console.error`.
+         */
+        readonly onError?: (error: unknown) => void;
+    };
+    /**
+     * Configuration options for {@link tap.time}, enforcing mutual exclusivity
+     * between console logging and custom handlers.
+     */
+    type TimeConfig = {
+        label: string;
+        onFinish?: never;
+    } | {
+        onFinish: (duration: Duration) => void;
+        label?: never;
+    };
+    /**
+     * Logs the piped value to the console or a custom logger, returning the value unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   42,
+     *   tap.log(), // logs: 42
+     *   tap.log({ label: "Count" }) // logs: [Count]: 42
+     * );
+     * ```
+     */
+    const log: <A>(options?: LogOptions<A>) => (a: A) => A;
+    /**
+     * Performs a deep structured inspect formatting on the piped value, returning it unchanged.
+     * In Node.js environments, this utilizes Node's `node:util` `inspect` utility.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   { user: { name: "Alice", details: { age: 30 } } },
+     *   tap.inspect({ label: "User Object", depth: 2 })
+     * );
+     * ```
+     */
+    const inspect: <A>(options?: InspectOptions) => (a: A) => A;
+    /**
+     * Triggers a fire-and-forget asynchronous side effect in the background,
+     * returning the piped value immediately and synchronously.
+     * Any errors thrown by the async function are caught and forwarded to `onError`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   user,
+     *   tap.async(async (u) => {
+     *     await saveToDatabase(u);
+     *   }, { onError: (err) => logError(err) })
+     * );
+     * ```
+     */
+    const async: <A>(fn: (a: A) => Promise<unknown>, options?: AsyncOptions) => (a: A) => A;
+    /**
+     * Runs a function and measures its execution duration, returning the value unchanged.
+     * Supports both synchronous and asynchronous functions. If the timed function returns
+     * a Promise, duration measurement resolves asynchronously upon resolution/rejection.
+     *
+     * @example
+     * ```ts
+     * // Time a synchronous computation
+     * pipe(
+     *   data,
+     *   tap.time(processData, { label: "sync-process" })
+     * );
+     *
+     * // Time an asynchronous fetch with custom metrics callback
+     * pipe(
+     *   data,
+     *   tap.time(fetchData, {
+     *     onFinish: (dur) => metrics.histogram("api.time", Duration.toMilliseconds(dur))
+     *   })
+     * );
+     * ```
+     */
+    const time: <A>(fn: (a: A) => unknown, config: TimeConfig) => (a: A) => A;
+}
 
 /**
  * Converts a curried function into a multi-argument function.

package/dist/composition.js

@@ -369,10 +369,117 @@ pipe.try = (f, onError) => (a) => {
 };
 
 // src/Composition/tap.ts
-var tap = (f) => (a) => {
-  f(a);
-  return a;
-};
+var import_node_util = require("util");
+
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
+  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
+  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
+// src/Composition/tap.ts
+function tap(f) {
+  return (a) => {
+    f(a);
+    return a;
+  };
+}
+((tap2) => {
+  tap2.log = (options) => (a) => {
+    const logger = options?.logger ?? console.log;
+    const formatter = options?.formatter ?? ((val) => {
+      try {
+        return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
+      } catch {
+        return String(val);
+      }
+    });
+    const formatted = formatter(a);
+    if (options?.label !== void 0) {
+      logger(`[${options.label}]: ${formatted}`);
+    } else {
+      logger(formatted);
+    }
+    return a;
+  };
+  tap2.inspect = (options) => (a) => {
+    const label = options?.label;
+    const depth = options?.depth ?? null;
+    const colors = options?.colors ?? true;
+    let formatted;
+    if (typeof import_node_util.inspect === "function") {
+      formatted = (0, import_node_util.inspect)(a, { depth, colors });
+    } else {
+      try {
+        formatted = JSON.stringify(a, null, 2);
+      } catch {
+        formatted = String(a);
+      }
+    }
+    if (label !== void 0) {
+      console.log(`[${label}]: ${formatted}`);
+    } else {
+      console.log(formatted);
+    }
+    return a;
+  };
+  tap2.async = (fn, options) => (a) => {
+    const onError = options?.onError ?? console.error;
+    fn(a).catch((err) => {
+      onError(err);
+    });
+    return a;
+  };
+  tap2.time = (fn, config) => (a) => {
+    const start = performance.now();
+    const triggerFinish = (duration) => {
+      if (config.label !== void 0) {
+        console.log(`[${config.label}]: ${Duration.toMilliseconds(duration)}ms`);
+      } else if (config.onFinish) {
+        config.onFinish(duration);
+      }
+    };
+    try {
+      const res = fn(a);
+      if (res instanceof Promise) {
+        res.then(() => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        }, () => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        });
+      } else {
+        const duration = Duration.milliseconds(performance.now() - start);
+        triggerFinish(duration);
+      }
+    } catch (err) {
+      const duration = Duration.milliseconds(performance.now() - start);
+      triggerFinish(duration);
+      throw err;
+    }
+    return a;
+  };
+})(tap || (tap = {}));
 
 // src/Composition/uncurry.ts
 function uncurry(f) {

package/dist/composition.mjs

@@ -27,7 +27,8 @@ import {
   uncurry,
   uncurry3,
   uncurry4
-} from "./chunk-3Q5UBRYB.mjs";
+} from "./chunk-TCE2UETM.mjs";
+import "./chunk-GBB6LVLI.mjs";
 export {
   and,
   compose,

package/dist/core.d.mts

@@ -1,6 +1,7 @@
-import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, i as WithFirst, n as WithSecond, h as WithErrors } from './Task-DcXhCZYg.mjs';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DcXhCZYg.mjs';
-import { Duration, NonEmptyList } from './types.mjs';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, i as WithFirst, n as WithSecond, h as WithErrors } from './Task-BprUabHP.mjs';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-BprUabHP.mjs';
+import { D as Duration } from './Duration-BTeT9D-q.mjs';
+import { NonEmptyList } from './types.mjs';
 
 /**
  * A type that can combine two values of type `A` into one, with a neutral starting value.
@@ -2591,7 +2592,7 @@ declare namespace TaskResult {
      * if (Result.isOk(result)) render(result.value);
      * ```
      */
-    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
+    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
     /**
      * Converts a TaskResult value into an object containing a single property.
      * Initiates the pipeline accumulator record.

package/dist/core.d.ts

@@ -1,6 +1,7 @@
-import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, i as WithFirst, n as WithSecond, h as WithErrors } from './Task-uupX7xd9.js';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-uupX7xd9.js';
-import { Duration, NonEmptyList } from './types.js';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, i as WithFirst, n as WithSecond, h as WithErrors } from './Task-Dt3ZMen6.js';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-Dt3ZMen6.js';
+import { D as Duration } from './Duration-BTeT9D-q.js';
+import { NonEmptyList } from './types.js';
 
 /**
  * A type that can combine two values of type `A` into one, with a neutral starting value.
@@ -2591,7 +2592,7 @@ declare namespace TaskResult {
      * if (Result.isOk(result)) render(result.value);
      * ```
      */
-    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
+    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
     /**
      * Converts a TaskResult value into an object containing a single property.
      * Initiates the pipeline accumulator record.

package/dist/core.js

@@ -1870,7 +1870,7 @@ var Task;
     };
     return { task, abort };
   };
-  Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.run = (signal) => (task) => task(signal);
   Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
   Task2.bind = (key, f) => (data) => (0, Task2.chain)(
     (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
@@ -1934,7 +1934,7 @@ var TaskResult3;
       ([of_, oa]) => Result.ap(oa)(of_)
     )
   );
-  TaskResult4.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult4.run = (signal) => (task) => task(signal);
   TaskResult4.bindTo = (key) => (data) => (0, TaskResult4.map)((a) => ({ [key]: a }))(data);
   TaskResult4.bind = (key, f) => (data) => (0, TaskResult4.chain)(
     (a) => (0, TaskResult4.map)((b) => ({ ...a, [key]: b }))(f(a))

package/dist/core.mjs

@@ -23,8 +23,8 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-4R4XUP4M.mjs";
-import "./chunk-5AFEEFE4.mjs";
+} from "./chunk-COGQKPIP.mjs";
+import "./chunk-GBB6LVLI.mjs";
 export {
   Combinable,
   Deferred,

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.mjs';
 export { Combinable, Failed, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Passed, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Validation } from './core.mjs';
-export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-DcXhCZYg.mjs';
+export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-BprUabHP.mjs';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.mjs';
-export { Brand, Duration, NonEmptyList, isNonEmptyList } from './types.mjs';
+export { B as Brand, D as Duration } from './Duration-BTeT9D-q.mjs';
+export { NonEmptyList, isNonEmptyList } from './types.mjs';

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.js';
 export { Combinable, Failed, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Passed, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Validation } from './core.js';
-export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-uupX7xd9.js';
+export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-Dt3ZMen6.js';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.js';
-export { Brand, Duration, NonEmptyList, isNonEmptyList } from './types.js';
+export { B as Brand, D as Duration } from './Duration-BTeT9D-q.js';
+export { NonEmptyList, isNonEmptyList } from './types.js';

package/dist/index.js

@@ -402,10 +402,120 @@ pipe.try = (f, onError) => (a) => {
 };
 
 // src/Composition/tap.ts
-var tap = (f) => (a) => {
-  f(a);
-  return a;
-};
+var import_node_util = require("util");
+
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/NonEmptyList.ts
+var isNonEmptyList = (list) => list.length > 0;
+
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
+  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
+  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
+// src/Composition/tap.ts
+function tap(f) {
+  return (a) => {
+    f(a);
+    return a;
+  };
+}
+((tap2) => {
+  tap2.log = (options) => (a) => {
+    const logger = options?.logger ?? console.log;
+    const formatter = options?.formatter ?? ((val) => {
+      try {
+        return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
+      } catch {
+        return String(val);
+      }
+    });
+    const formatted = formatter(a);
+    if (options?.label !== void 0) {
+      logger(`[${options.label}]: ${formatted}`);
+    } else {
+      logger(formatted);
+    }
+    return a;
+  };
+  tap2.inspect = (options) => (a) => {
+    const label = options?.label;
+    const depth = options?.depth ?? null;
+    const colors = options?.colors ?? true;
+    let formatted;
+    if (typeof import_node_util.inspect === "function") {
+      formatted = (0, import_node_util.inspect)(a, { depth, colors });
+    } else {
+      try {
+        formatted = JSON.stringify(a, null, 2);
+      } catch {
+        formatted = String(a);
+      }
+    }
+    if (label !== void 0) {
+      console.log(`[${label}]: ${formatted}`);
+    } else {
+      console.log(formatted);
+    }
+    return a;
+  };
+  tap2.async = (fn, options) => (a) => {
+    const onError = options?.onError ?? console.error;
+    fn(a).catch((err2) => {
+      onError(err2);
+    });
+    return a;
+  };
+  tap2.time = (fn, config) => (a) => {
+    const start = performance.now();
+    const triggerFinish = (duration) => {
+      if (config.label !== void 0) {
+        console.log(`[${config.label}]: ${Duration.toMilliseconds(duration)}ms`);
+      } else if (config.onFinish) {
+        config.onFinish(duration);
+      }
+    };
+    try {
+      const res = fn(a);
+      if (res instanceof Promise) {
+        res.then(() => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        }, () => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        });
+      } else {
+        const duration = Duration.milliseconds(performance.now() - start);
+        triggerFinish(duration);
+      }
+    } catch (err2) {
+      const duration = Duration.milliseconds(performance.now() - start);
+      triggerFinish(duration);
+      throw err2;
+    }
+    return a;
+  };
+})(tap || (tap = {}));
 
 // src/Composition/uncurry.ts
 function uncurry(f) {
@@ -575,34 +685,6 @@ var Maybe;
   };
 })(Maybe || (Maybe = {}));
 
-// src/Types/Brand.ts
-var Brand;
-((Brand2) => {
-  Brand2.wrap = () => (value) => value;
-  Brand2.unwrap = (branded) => branded;
-})(Brand || (Brand = {}));
-
-// src/Types/Duration.ts
-var Duration;
-((Duration2) => {
-  const wrap = Brand.wrap();
-  Duration2.milliseconds = (ms) => wrap(ms);
-  Duration2.seconds = (s) => wrap(s * 1e3);
-  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
-  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
-  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
-  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
-  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
-  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
-  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
-  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
-  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
-  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
-})(Duration || (Duration = {}));
-
-// src/Types/NonEmptyList.ts
-var isNonEmptyList = (list) => list.length > 0;
-
 // src/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -2243,7 +2325,7 @@ var Task;
     };
     return { task, abort };
   };
-  Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.run = (signal) => (task) => task(signal);
   Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
   Task2.bind = (key, f) => (data) => (0, Task2.chain)(
     (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
@@ -2307,7 +2389,7 @@ var TaskResult3;
       ([of_, oa]) => Result.ap(oa)(of_)
     )
   );
-  TaskResult4.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult4.run = (signal) => (task) => task(signal);
   TaskResult4.bindTo = (key) => (data) => (0, TaskResult4.map)((a) => ({ [key]: a }))(data);
   TaskResult4.bind = (key, f) => (data) => (0, TaskResult4.chain)(
     (a) => (0, TaskResult4.map)((b) => ({ ...a, [key]: b }))(f(a))
@@ -3035,6 +3117,7 @@ var Num;
   };
   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) => {
     if (s.trim() === "") {
       return Maybe.none();

package/dist/index.mjs

@@ -27,7 +27,7 @@ import {
   uncurry,
   uncurry3,
   uncurry4
-} from "./chunk-3Q5UBRYB.mjs";
+} from "./chunk-TCE2UETM.mjs";
 import {
   Arr,
   Dict,
@@ -35,7 +35,7 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-BQKKTTJS.mjs";
+} from "./chunk-V37OUM35.mjs";
 import {
   Combinable,
   Deferred,
@@ -61,12 +61,12 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-4R4XUP4M.mjs";
+} from "./chunk-COGQKPIP.mjs";
 import {
   Brand,
   Duration,
   isNonEmptyList
-} from "./chunk-5AFEEFE4.mjs";
+} from "./chunk-GBB6LVLI.mjs";
 export {
   Arr,
   Brand,