@nlozgachev/pipelined 0.42.0 → 0.43.0

package/dist/core.js

@@ -38,9 +38,6 @@ __export(Core_exports, {
   Result: () => Result,
   State: () => State,
   Task: () => Task,
-  TaskMaybe: () => TaskMaybe,
-  TaskResult: () => TaskResult3,
-  TaskValidation: () => TaskValidation,
   These: () => These,
   Tuple: () => Tuple,
   Validation: () => Validation
@@ -1649,6 +1646,162 @@ var State;
   )(data);
 })(State || (State = {}));
 
+// src/Core/TaskMaybe.ts
+var TaskMaybe;
+((TaskMaybe2) => {
+  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
+  TaskMaybe2.none = () => Task.resolve(Maybe.none());
+  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
+  TaskMaybe2.fromNullable = (value) => Task.resolve(Maybe.fromNullable(value));
+  TaskMaybe2.fromResult = (result) => Task.resolve(Result.toMaybe(result));
+  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
+  TaskMaybe2.tryCatch = (f) => Task.from((signal) => Promise.resolve(f(signal)).then(Maybe.some).catch(() => Maybe.none()));
+  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
+  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
+  TaskMaybe2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+      ([of_, oa]) => Maybe.ap(oa)(of_)
+    )
+  );
+  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
+  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
+  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
+  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
+  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
+  TaskMaybe2.toResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskMaybe2.recover = (fallback) => (data) => Task.chain((maybe) => Maybe.isNone(maybe) ? fallback() : Task.resolve(maybe))(data);
+  TaskMaybe2.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Maybe.isNone(res)) {
+          return res;
+        }
+        record[keys[i]] = res.value;
+      }
+      return Maybe.some(record);
+    });
+  });
+})(TaskMaybe || (TaskMaybe = {}));
+
+// src/Core/TaskResult.ts
+var TaskResult;
+((TaskResult2) => {
+  TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
+  TaskResult2.err = (error) => Task.resolve(Result.err(error));
+  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
+  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
+  TaskResult2.fromResult = (result) => Task.resolve(result);
+  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult2.tryCatch = (f, onError) => Task.from((signal) => Promise.resolve(f(signal)).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
+  TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
+  TaskResult2.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
+    data
+  );
+  TaskResult2.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
+  TaskResult2.match = (cases) => (data) => Task.map(Result.match(cases))(data);
+  TaskResult2.recover = (fallback) => (data) => Task.chain(
+    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
+  )(data);
+  TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
+  TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
+  TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
+  TaskResult2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+      ([of_, oa]) => Result.ap(oa)(of_)
+    )
+  );
+  TaskResult2.run = (signal) => (task) => task(signal);
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskResult2.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Result.isErr(res)) {
+          return res;
+        }
+        record[keys[i]] = res.value;
+      }
+      return Result.ok(record);
+    });
+  });
+})(TaskResult || (TaskResult = {}));
+
+// src/internal/InternalTypes.ts
+var isNonEmptyArr = (list) => list.length > 0;
+
+// src/Core/TaskValidation.ts
+var TaskValidation;
+((TaskValidation2) => {
+  TaskValidation2.passed = (value) => Task.resolve(Validation.passed(value));
+  TaskValidation2.failed = (error) => Task.resolve(Validation.failed(error));
+  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.failedAll(errors));
+  TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
+  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.failed(onNull()) : Validation.passed(value));
+  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.failed(onNone()) : Validation.passed(maybe.value));
+  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
+  TaskValidation2.tryCatch = (f, onError) => Task.from(
+    (signal) => Promise.resolve(f(signal)).then(Validation.passed).catch((error) => Validation.failed(onError(error)))
+  );
+  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
+  TaskValidation2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+      ([vf, va]) => Validation.ap(va)(vf)
+    )
+  );
+  TaskValidation2.fold = (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data);
+  TaskValidation2.match = (cases) => (data) => Task.map(Validation.match(cases))(data);
+  TaskValidation2.getOrElse = (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data);
+  TaskValidation2.tap = (f) => (data) => Task.map(Validation.tap(f))(data);
+  TaskValidation2.recover = (fallback) => (data) => Task.chain(
+    (validation) => Validation.isPassed(validation) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
+  TaskValidation2.product = (first, second) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(first(signal)), Deferred.toPromise(second(signal))]).then(
+      ([va, vb]) => Validation.product(va, vb)
+    )
+  );
+  TaskValidation2.productAll = (data) => Task.from(
+    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then((results) => {
+      const [first, ...rest] = results;
+      return Validation.productAll([first, ...rest]);
+    })
+  );
+  TaskValidation2.mapError = (f) => (data) => Task.map(Validation.mapError(f))(data);
+  TaskValidation2.tapError = (f) => (data) => Task.map(Validation.tapError(f))(data);
+  TaskValidation2.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      const errors = [];
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Validation.isPassed(res)) {
+          record[keys[i]] = res.value;
+        } else {
+          errors.push(...res.errors);
+        }
+      }
+      return isNonEmptyArr(errors) ? Validation.failedAll(errors) : Validation.passed(record);
+    });
+  });
+})(TaskValidation || (TaskValidation = {}));
+
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var getMs2 = (duration) => Duration.toMilliseconds(duration);
@@ -1805,14 +1958,16 @@ var Task;
   Task2.timeout = (duration, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
     let timerId;
-    function cleanUp() {
-      clearTimeout(timerId);
-      outerSignal?.removeEventListener("abort", onOuterAbort);
-    }
-    function onOuterAbort() {
+    let cleanUp = () => {
+    };
+    const onOuterAbort = () => {
       cleanUp();
       controller.abort();
-    }
+    };
+    cleanUp = () => {
+      clearTimeout(timerId);
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
     if (outerSignal) {
       if (outerSignal.aborted) {
         controller.abort();
@@ -1857,123 +2012,11 @@ var Task;
   Task2.bind = (key, f) => (data) => (0, Task2.chain)(
     (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  Task2.Maybe = TaskMaybe;
+  Task2.Result = TaskResult;
+  Task2.Validation = TaskValidation;
 })(Task || (Task = {}));
 
-// src/Core/TaskMaybe.ts
-var TaskMaybe;
-((TaskMaybe2) => {
-  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
-  TaskMaybe2.none = () => Task.resolve(Maybe.none());
-  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
-  TaskMaybe2.fromNullable = (value) => Task.resolve(Maybe.fromNullable(value));
-  TaskMaybe2.fromResult = (result) => Task.resolve(Result.toMaybe(result));
-  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
-  TaskMaybe2.tryCatch = (f) => Task.from((signal) => f(signal).then(Maybe.some).catch(() => Maybe.none()));
-  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
-  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
-  TaskMaybe2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
-      ([of_, oa]) => Maybe.ap(oa)(of_)
-    )
-  );
-  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
-  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
-  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
-  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
-  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
-  TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
-  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
-  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
-    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
-  )(data);
-})(TaskMaybe || (TaskMaybe = {}));
-
-// src/Core/TaskResult.ts
-var TaskResult3;
-((TaskResult4) => {
-  TaskResult4.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult4.err = (error) => Task.resolve(Result.err(error));
-  TaskResult4.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
-  TaskResult4.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
-  TaskResult4.fromResult = (result) => Task.resolve(result);
-  TaskResult4.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult4.tryCatch = (f, onError) => Task.from((signal) => f(signal).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult4.map = (f) => (data) => Task.map(Result.map(f))(data);
-  TaskResult4.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
-  TaskResult4.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
-    data
-  );
-  TaskResult4.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
-  TaskResult4.match = (cases) => (data) => Task.map(Result.match(cases))(data);
-  TaskResult4.recover = (fallback) => (data) => Task.chain(
-    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
-  )(data);
-  TaskResult4.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
-  TaskResult4.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult4.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
-  TaskResult4.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
-      ([of_, oa]) => Result.ap(oa)(of_)
-    )
-  );
-  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))
-  )(data);
-  TaskResult4.struct = (fields) => Task.from((signal) => {
-    const keys = Object.keys(fields);
-    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
-    return Promise.all(promises).then((results) => {
-      const record = {};
-      for (let i = 0; i < keys.length; i++) {
-        const res = results[i];
-        if (Result.isErr(res)) {
-          return res;
-        }
-        record[keys[i]] = res.value;
-      }
-      return Result.ok(record);
-    });
-  });
-})(TaskResult3 || (TaskResult3 = {}));
-
-// src/Core/TaskValidation.ts
-var TaskValidation;
-((TaskValidation2) => {
-  TaskValidation2.passed = (value) => Task.resolve(Validation.passed(value));
-  TaskValidation2.failed = (error) => Task.resolve(Validation.failed(error));
-  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.failedAll(errors));
-  TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
-  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.failed(onNull()) : Validation.passed(value));
-  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.failed(onNone()) : Validation.passed(maybe.value));
-  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
-  TaskValidation2.tryCatch = (f, onError) => Task.from((signal) => f(signal).then(Validation.passed).catch((error) => Validation.failed(onError(error))));
-  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
-  TaskValidation2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
-      ([vf, va]) => Validation.ap(va)(vf)
-    )
-  );
-  TaskValidation2.fold = (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data);
-  TaskValidation2.match = (cases) => (data) => Task.map(Validation.match(cases))(data);
-  TaskValidation2.getOrElse = (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data);
-  TaskValidation2.tap = (f) => (data) => Task.map(Validation.tap(f))(data);
-  TaskValidation2.recover = (fallback) => (data) => Task.chain(
-    (validation) => Validation.isPassed(validation) ? Task.resolve(validation) : fallback(validation.errors)
-  )(data);
-  TaskValidation2.product = (first, second) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(first(signal)), Deferred.toPromise(second(signal))]).then(
-      ([va, vb]) => Validation.product(va, vb)
-    )
-  );
-  TaskValidation2.productAll = (data) => Task.from(
-    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then(
-      (results) => Validation.productAll(results)
-    )
-  );
-})(TaskValidation || (TaskValidation = {}));
-
 // src/Core/These.ts
 var These;
 ((These2) => {
@@ -2096,11 +2139,10 @@ var Validation;
   Validation2.map = (f) => (data) => (0, Validation2.isPassed)(data) ? (0, Validation2.passed)(f(data.value)) : data;
   Validation2.mapError = (f) => (data) => (0, Validation2.isFailed)(data) ? (0, Validation2.failedAll)(data.errors.map(f)) : data;
   Validation2.ap = (arg) => (data) => {
-    if ((0, Validation2.isPassed)(data) && (0, Validation2.isPassed)(arg)) {
-      return (0, Validation2.passed)(data.value(arg.value));
+    if ((0, Validation2.isPassed)(data)) {
+      return (0, Validation2.isPassed)(arg) ? (0, Validation2.passed)(data.value(arg.value)) : (0, Validation2.failedAll)(arg.errors);
     }
-    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
-    return (0, Validation2.failedAll)(errors);
+    return (0, Validation2.isPassed)(arg) ? (0, Validation2.failedAll)(data.errors) : (0, Validation2.failedAll)([...data.errors, ...arg.errors]);
   };
   Validation2.fold = (onFailed, onPassed) => (data) => (0, Validation2.isPassed)(data) ? onPassed(data.value) : onFailed(data.errors);
   Validation2.match = (cases) => (data) => (0, Validation2.isPassed)(data) ? cases.passed(data.value) : cases.failed(data.errors);
@@ -2123,11 +2165,10 @@ var Validation;
   Validation2.toMaybe = (data) => (0, Validation2.isPassed)(data) ? Maybe.some(data.value) : Maybe.none();
   Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.passed)(data.value) : (0, Validation2.failed)(data.error);
   Validation2.product = (first, second) => {
-    if ((0, Validation2.isPassed)(first) && (0, Validation2.isPassed)(second)) {
-      return (0, Validation2.passed)([first.value, second.value]);
+    if ((0, Validation2.isPassed)(first)) {
+      return (0, Validation2.isPassed)(second) ? (0, Validation2.passed)([first.value, second.value]) : (0, Validation2.failedAll)(second.errors);
     }
-    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
-    return (0, Validation2.failedAll)(errors);
+    return (0, Validation2.isPassed)(second) ? (0, Validation2.failedAll)(first.errors) : (0, Validation2.failedAll)([...first.errors, ...second.errors]);
   };
   Validation2.productAll = (data) => {
     const values = [];
@@ -2139,7 +2180,7 @@ var Validation;
         errors.push(...v.errors);
       }
     }
-    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
+    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
   };
   Validation2.struct = (fields) => {
     const record = {};
@@ -2154,7 +2195,7 @@ var Validation;
         }
       }
     }
-    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
+    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
   };
 })(Validation || (Validation = {}));
 // Annotate the CommonJS export names for ESM import in node:
@@ -2177,9 +2218,6 @@ var Validation;
   Result,
   State,
   Task,
-  TaskMaybe,
-  TaskResult,
-  TaskValidation,
   These,
   Tuple,
   Validation

package/dist/core.mjs

@@ -17,14 +17,11 @@ import {
   Result,
   State,
   Task,
-  TaskMaybe,
-  TaskResult,
-  TaskValidation,
   These,
   Tuple,
   Validation
-} from "./chunk-OAP765G3.mjs";
-import "./chunk-GBB6LVLI.mjs";
+} from "./chunk-CHRXZIJU.mjs";
+import "./chunk-74JKKJ4R.mjs";
 export {
   Combinable,
   Deferred,
@@ -44,9 +41,6 @@ export {
   Result,
   State,
   Task,
-  TaskMaybe,
-  TaskResult,
-  TaskValidation,
   These,
   Tuple,
   Validation

package/dist/index.d.mts

@@ -1,6 +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-BprUabHP.mjs';
-export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.mjs';
-export { B as Brand, D as Duration } from './Duration-BTeT9D-q.mjs';
-export { NonEmptyList, isNonEmptyList } from './types.mjs';
+export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.mjs';
+export { D as Deferred } from './InternalTypes-DsCqxWZm.mjs';
+export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, V as Validation } from './Validation-Do6uWLLZ.mjs';
+export { Arr, Dict, NonEmptyRecord, Num, Rec, Str, Uniq } from './utils.mjs';
+export { Brand, Duration } from './types.mjs';

package/dist/index.d.ts

@@ -1,6 +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-Dt3ZMen6.js';
-export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.js';
-export { B as Brand, D as Duration } from './Duration-BTeT9D-q.js';
-export { NonEmptyList, isNonEmptyList } from './types.js';
+export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.js';
+export { D as Deferred } from './InternalTypes-DuzMFAfJ.js';
+export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, V as Validation } from './Validation-BOPLiDqa.js';
+export { Arr, Dict, NonEmptyRecord, Num, Rec, Str, Uniq } from './utils.js';
+export { Brand, Duration } from './types.js';