@nlozgachev/pipelined 0.32.0 → 0.33.0

package/dist/types.d.mts

@@ -1,4 +1,31 @@
-export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+/**
+ * A list that is guaranteed to have at least one element.
+ * Useful for ensuring functions receive non-empty input and for
+ * accumulating errors in Validation.
+ *
+ * @example
+ * ```ts
+ * const errors: NonEmptyList<string> = ["First error", "Second error"];
+ *
+ * // TypeScript ensures at least one element:
+ * const invalid: NonEmptyList<string> = []; // Error!
+ * ```
+ */
+type NonEmptyList<A> = readonly [A, ...A[]];
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ * ```ts
+ * const items: string[] = getItems();
+ *
+ * if (isNonEmptyList(items)) {
+ *   // TypeScript knows items has at least one element
+ *   const first = items[0]; // string, not string | undefined
+ * }
+ * ```
+ */
+declare const isNonEmptyList: <A>(list: readonly A[]) => list is NonEmptyList<A>;
 
 declare const _brand: unique symbol;
 /**
@@ -51,4 +78,79 @@ declare namespace Brand {
     const unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
 }
 
-export { Brand };
+/**
+ * A branded nominal type representing a duration of time in milliseconds.
+ * Use Duration to ensure safe time-based operators and clear unit conversions.
+ *
+ * @example
+ * ```ts
+ * const halfSecond = Duration.milliseconds(500);
+ * const twoSeconds = Duration.seconds(2);
+ * const total = pipe(halfSecond, Duration.add(twoSeconds));
+ *
+ * Duration.toSeconds(total); // 2.5
+ * ```
+ */
+type Duration = Brand<"Duration", number>;
+declare namespace Duration {
+    /**
+     * Creates a Duration from milliseconds.
+     */
+    const milliseconds: (ms: number) => Duration;
+    /**
+     * Creates a Duration from seconds.
+     */
+    const seconds: (s: number) => Duration;
+    /**
+     * Creates a Duration from minutes.
+     */
+    const minutes: (m: number) => Duration;
+    /**
+     * Creates a Duration from hours.
+     */
+    const hours: (h: number) => Duration;
+    /**
+     * Creates a Duration from days.
+     */
+    const days: (d: number) => Duration;
+    /**
+     * Converts a Duration back to raw milliseconds.
+     */
+    const toMilliseconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to seconds.
+     */
+    const toSeconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to minutes.
+     */
+    const toMinutes: (d: Duration) => number;
+    /**
+     * Converts a Duration to hours.
+     */
+    const toHours: (d: Duration) => number;
+    /**
+     * Converts a Duration to days.
+     */
+    const toDays: (d: Duration) => number;
+    /**
+     * Adds two Durations together.
+     *
+     * @example
+     * ```ts
+     * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
+     * ```
+     */
+    const add: (other: Duration) => (self: Duration) => Duration;
+    /**
+     * Subtracts the other Duration from this one.
+     *
+     * @example
+     * ```ts
+     * pipe(Duration.seconds(1), Duration.subtract(Duration.milliseconds(500))); // 500ms
+     * ```
+     */
+    const subtract: (other: Duration) => (self: Duration) => Duration;
+}
+
+export { Brand, Duration, type NonEmptyList, isNonEmptyList };

package/dist/types.d.ts

@@ -1,4 +1,31 @@
-export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.js';
+/**
+ * A list that is guaranteed to have at least one element.
+ * Useful for ensuring functions receive non-empty input and for
+ * accumulating errors in Validation.
+ *
+ * @example
+ * ```ts
+ * const errors: NonEmptyList<string> = ["First error", "Second error"];
+ *
+ * // TypeScript ensures at least one element:
+ * const invalid: NonEmptyList<string> = []; // Error!
+ * ```
+ */
+type NonEmptyList<A> = readonly [A, ...A[]];
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ * ```ts
+ * const items: string[] = getItems();
+ *
+ * if (isNonEmptyList(items)) {
+ *   // TypeScript knows items has at least one element
+ *   const first = items[0]; // string, not string | undefined
+ * }
+ * ```
+ */
+declare const isNonEmptyList: <A>(list: readonly A[]) => list is NonEmptyList<A>;
 
 declare const _brand: unique symbol;
 /**
@@ -51,4 +78,79 @@ declare namespace Brand {
     const unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
 }
 
-export { Brand };
+/**
+ * A branded nominal type representing a duration of time in milliseconds.
+ * Use Duration to ensure safe time-based operators and clear unit conversions.
+ *
+ * @example
+ * ```ts
+ * const halfSecond = Duration.milliseconds(500);
+ * const twoSeconds = Duration.seconds(2);
+ * const total = pipe(halfSecond, Duration.add(twoSeconds));
+ *
+ * Duration.toSeconds(total); // 2.5
+ * ```
+ */
+type Duration = Brand<"Duration", number>;
+declare namespace Duration {
+    /**
+     * Creates a Duration from milliseconds.
+     */
+    const milliseconds: (ms: number) => Duration;
+    /**
+     * Creates a Duration from seconds.
+     */
+    const seconds: (s: number) => Duration;
+    /**
+     * Creates a Duration from minutes.
+     */
+    const minutes: (m: number) => Duration;
+    /**
+     * Creates a Duration from hours.
+     */
+    const hours: (h: number) => Duration;
+    /**
+     * Creates a Duration from days.
+     */
+    const days: (d: number) => Duration;
+    /**
+     * Converts a Duration back to raw milliseconds.
+     */
+    const toMilliseconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to seconds.
+     */
+    const toSeconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to minutes.
+     */
+    const toMinutes: (d: Duration) => number;
+    /**
+     * Converts a Duration to hours.
+     */
+    const toHours: (d: Duration) => number;
+    /**
+     * Converts a Duration to days.
+     */
+    const toDays: (d: Duration) => number;
+    /**
+     * Adds two Durations together.
+     *
+     * @example
+     * ```ts
+     * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
+     * ```
+     */
+    const add: (other: Duration) => (self: Duration) => Duration;
+    /**
+     * Subtracts the other Duration from this one.
+     *
+     * @example
+     * ```ts
+     * pipe(Duration.seconds(1), Duration.subtract(Duration.milliseconds(500))); // 500ms
+     * ```
+     */
+    const subtract: (other: Duration) => (self: Duration) => Duration;
+}
+
+export { Brand, Duration, type NonEmptyList, isNonEmptyList };

package/dist/types.js

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Types_exports = {};
 __export(Types_exports, {
   Brand: () => Brand,
+  Duration: () => Duration,
   isNonEmptyList: () => isNonEmptyList
 });
 module.exports = __toCommonJS(Types_exports);
@@ -32,10 +33,29 @@ var Brand;
   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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Brand,
+  Duration,
   isNonEmptyList
 });

package/dist/types.mjs

@@ -1,10 +1,13 @@
-import {
-  Brand
-} from "./chunk-BYWKZLHM.mjs";
+import "./chunk-IPP4XFYH.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
+import {
+  Brand,
+  Duration
+} from "./chunk-VWVPHDZO.mjs";
 export {
   Brand,
+  Duration,
   isNonEmptyList
 };

package/dist/utils.d.mts

@@ -1,5 +1,5 @@
-import { M as Maybe, E as Equality, b as Ordering, R as Result, T as Task } from './Task-CJZfcOkO.mjs';
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-5na0QzS4.mjs';
+import { NonEmptyList } from './types.mjs';
 
 /**
  * Functional array utilities that compose well with pipe.
@@ -140,6 +140,38 @@ declare namespace Arr {
      * ```
      */
     const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    /**
+     * Narrows a list of Maybe values down to a list of their underlying values,
+     * discarding all None instances.
+     *
+     * @example
+     * ```ts
+     * Arr.compact([Maybe.some(1), Maybe.none(), Maybe.some(3)]); // [1, 3]
+     * ```
+     */
+    const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
+    /**
+     * Separates an array of Result values into two separate lists of errors and successes.
+     * Returns a tuple containing `[errors, successes]`.
+     *
+     * @example
+     * ```ts
+     * Arr.separate([Result.ok(1), Result.error("bad"), Result.ok(3)]); // [["bad"], [1, 3]]
+     * ```
+     */
+    const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+    /**
+     * Maps each element to a Result, and separates the results into a tuple of failures and successes.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3, 4],
+     *   Arr.partitionMap(n => n % 2 === 0 ? Result.ok(n) : Result.error(`odd: ${n}`))
+     * ); // [["odd: 1", "odd: 3"], [2, 4]]
+     * ```
+     */
+    const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
     /**
      * Groups elements by a key function.
      *
@@ -1390,6 +1422,16 @@ declare namespace Str {
          */
         float: (s: string) => Maybe<number>;
     };
+    /**
+     * Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
+     *
+     * @example
+     * ```ts
+     * Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
+     * Str.parseJson('invalid');  // Error(SyntaxError)
+     * ```
+     */
+    const parseJson: (s: string) => Result<SyntaxError, unknown>;
 }
 
 /**

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, E as Equality, b as Ordering, R as Result, T as Task } from './Task-CjYKLeTY.js';
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-DeiWgoeJ.js';
+import { NonEmptyList } from './types.js';
 
 /**
  * Functional array utilities that compose well with pipe.
@@ -140,6 +140,38 @@ declare namespace Arr {
      * ```
      */
     const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    /**
+     * Narrows a list of Maybe values down to a list of their underlying values,
+     * discarding all None instances.
+     *
+     * @example
+     * ```ts
+     * Arr.compact([Maybe.some(1), Maybe.none(), Maybe.some(3)]); // [1, 3]
+     * ```
+     */
+    const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
+    /**
+     * Separates an array of Result values into two separate lists of errors and successes.
+     * Returns a tuple containing `[errors, successes]`.
+     *
+     * @example
+     * ```ts
+     * Arr.separate([Result.ok(1), Result.error("bad"), Result.ok(3)]); // [["bad"], [1, 3]]
+     * ```
+     */
+    const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+    /**
+     * Maps each element to a Result, and separates the results into a tuple of failures and successes.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3, 4],
+     *   Arr.partitionMap(n => n % 2 === 0 ? Result.ok(n) : Result.error(`odd: ${n}`))
+     * ); // [["odd: 1", "odd: 3"], [2, 4]]
+     * ```
+     */
+    const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
     /**
      * Groups elements by a key function.
      *
@@ -1390,6 +1422,16 @@ declare namespace Str {
          */
         float: (s: string) => Maybe<number>;
     };
+    /**
+     * Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
+     *
+     * @example
+     * ```ts
+     * Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
+     * Str.parseJson('invalid');  // Error(SyntaxError)
+     * ```
+     */
+    const parseJson: (s: string) => Result<SyntaxError, unknown>;
 }
 
 /**

package/dist/utils.js

@@ -68,6 +68,15 @@ var Result;
     return data;
   };
   Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
+  Result2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result2.error)(onNull()) : (0, Result2.ok)(value);
+  Result2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result2.error)(onNone()) : (0, Result2.ok)(maybe.value);
+  Result2.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result2.ok)(f(...args));
+    } catch (e) {
+      return (0, Result2.error)(onError(e));
+    }
+  };
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isError)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
@@ -102,8 +111,34 @@ var Maybe;
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
 })(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/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs = (ms) => typeof ms === "number" ? ms : Duration.toMilliseconds(ms);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
@@ -144,7 +179,7 @@ var Task;
       timerId = setTimeout(() => {
         signal?.removeEventListener("abort", onAbort);
         resolve2(toPromise(data, signal));
-      }, ms);
+      }, getMs(ms));
     })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
@@ -167,7 +202,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, getMs(ms || 0));
       });
     };
     const run2 = (left) => {
@@ -200,7 +235,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, getMs(ms || 0));
       });
     };
     const run2 = (attempt, lastValue) => {
@@ -216,7 +251,39 @@ var Task;
     };
     return run2(1);
   });
-  Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
+  Task2.race = (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.fromPromise(new Promise(() => {
+      }));
+    }
+    return (0, Task2.from)((outerSignal) => {
+      const controllers = tasks.map(() => new AbortController());
+      const onOuterAbort = () => {
+        for (const ctrl of controllers) ctrl.abort();
+      };
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          onOuterAbort();
+        } else {
+          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+        }
+      }
+      const promises = tasks.map((task, idx) => {
+        const ctrl = controllers[idx];
+        return toPromise(task, ctrl.signal).then((result) => {
+          for (let i = 0; i < controllers.length; i++) {
+            if (i !== idx) {
+              controllers[i].abort();
+            }
+          }
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          return result;
+        });
+      });
+      return Promise.race(promises);
+    });
+  };
+  Task2.sequence = (tasks) => (0, Task2.from)((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
@@ -257,7 +324,7 @@ var Task;
           controller.abort();
           cleanUp();
           resolve2(Result.error(onTimeout()));
-        }, ms);
+        }, getMs(ms));
       })
     ]);
   });
@@ -342,6 +409,40 @@ var Arr;
     }
     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) {
@@ -873,6 +974,13 @@ var Str;
       return isNaN(n) ? Maybe.none() : Maybe.some(n);
     }
   };
+  Str2.parseJson = (s) => {
+    try {
+      return Result.ok(JSON.parse(s));
+    } catch (e) {
+      return Result.error(e);
+    }
+  };
 })(Str || (Str = {}));
 
 // src/Utils/Uniq.ts

package/dist/utils.mjs

@@ -5,9 +5,10 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-EHQFUWZW.mjs";
-import "./chunk-TK5ZCGP2.mjs";
+} from "./chunk-W53ZYTLX.mjs";
+import "./chunk-GSTKY7MF.mjs";
 import "./chunk-DBIC62UV.mjs";
+import "./chunk-VWVPHDZO.mjs";
 export {
   Arr,
   Dict,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.32.0",
+	"version": "0.33.0",
 	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",

package/dist/NonEmptyList-BlGFjor5.d.mts

@@ -1,30 +0,0 @@
-/**
- * A list that is guaranteed to have at least one element.
- * Useful for ensuring functions receive non-empty input and for
- * accumulating errors in Validation.
- *
- * @example
- * ```ts
- * const errors: NonEmptyList<string> = ["First error", "Second error"];
- *
- * // TypeScript ensures at least one element:
- * const invalid: NonEmptyList<string> = []; // Error!
- * ```
- */
-type NonEmptyList<A> = readonly [A, ...A[]];
-/**
- * Type guard that checks if an array is non-empty.
- *
- * @example
- * ```ts
- * const items: string[] = getItems();
- *
- * if (isNonEmptyList(items)) {
- *   // TypeScript knows items has at least one element
- *   const first = items[0]; // string, not string | undefined
- * }
- * ```
- */
-declare const isNonEmptyList: <A>(list: readonly A[]) => list is NonEmptyList<A>;
-
-export { type NonEmptyList as N, isNonEmptyList as i };

package/dist/NonEmptyList-BlGFjor5.d.ts

@@ -1,30 +0,0 @@
-/**
- * A list that is guaranteed to have at least one element.
- * Useful for ensuring functions receive non-empty input and for
- * accumulating errors in Validation.
- *
- * @example
- * ```ts
- * const errors: NonEmptyList<string> = ["First error", "Second error"];
- *
- * // TypeScript ensures at least one element:
- * const invalid: NonEmptyList<string> = []; // Error!
- * ```
- */
-type NonEmptyList<A> = readonly [A, ...A[]];
-/**
- * Type guard that checks if an array is non-empty.
- *
- * @example
- * ```ts
- * const items: string[] = getItems();
- *
- * if (isNonEmptyList(items)) {
- *   // TypeScript knows items has at least one element
- *   const first = items[0]; // string, not string | undefined
- * }
- * ```
- */
-declare const isNonEmptyList: <A>(list: readonly A[]) => list is NonEmptyList<A>;
-
-export { type NonEmptyList as N, isNonEmptyList as i };

package/dist/chunk-BYWKZLHM.mjs

@@ -1,10 +0,0 @@
-// src/Types/Brand.ts
-var Brand;
-((Brand2) => {
-  Brand2.wrap = () => (value) => value;
-  Brand2.unwrap = (branded) => branded;
-})(Brand || (Brand = {}));
-
-export {
-  Brand
-};