@nlozgachev/pipelined 0.30.0 → 0.32.0

package/dist/core.js

@@ -20,12 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/Core/index.ts
 var Core_exports = {};
 __export(Core_exports, {
+  Combinable: () => Combinable,
   Deferred: () => Deferred,
+  Equality: () => Equality,
+  Lazy: () => Lazy,
   Lens: () => Lens,
   Logged: () => Logged,
   Maybe: () => Maybe,
   Op: () => Op,
   Optional: () => Optional,
+  Ordering: () => Ordering,
   Predicate: () => Predicate,
   Reader: () => Reader,
   Refinement: () => Refinement,
@@ -43,65 +47,6 @@ __export(Core_exports, {
 });
 module.exports = __toCommonJS(Core_exports);
 
-// src/Core/Deferred.ts
-var Deferred;
-((Deferred2) => {
-  Deferred2.fromPromise = (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)) }
-  );
-  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
-})(Deferred || (Deferred = {}));
-
-// src/Core/Lens.ts
-var Lens;
-((Lens2) => {
-  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
-  Lens2.prop = () => (key) => (0, Lens2.make)(
-    (s) => s[key],
-    (a) => (s) => ({ ...s, [key]: a })
-  );
-  Lens2.get = (lens) => (s) => lens.get(s);
-  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
-  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)(
-    (s) => inner.get(outer.get(s)),
-    (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
-  );
-  Lens2.andThenOptional = (inner) => (outer) => ({
-    get: (s) => inner.get(outer.get(s)),
-    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
-  });
-  Lens2.toOptional = (lens) => ({
-    get: (s) => ({ kind: "Some", value: lens.get(s) }),
-    set: lens.set
-  });
-})(Lens || (Lens = {}));
-
-// src/Core/Logged.ts
-var Logged;
-((Logged2) => {
-  Logged2.make = (value) => ({ value, log: [] });
-  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
-  Logged2.map = (f) => (data) => ({
-    value: f(data.value),
-    log: data.log
-  });
-  Logged2.chain = (f) => (data) => {
-    const next = f(data.value);
-    return { value: next.value, log: [...data.log, ...next.log] };
-  };
-  Logged2.ap = (arg) => (data) => ({
-    value: data.value(arg.value),
-    log: [...data.log, ...arg.log]
-  });
-  Logged2.tap = (f) => (data) => {
-    f(data.value);
-    return data;
-  };
-  Logged2.run = (data) => [data.value, data.log];
-})(Logged || (Logged = {}));
-
 // src/Core/Result.ts
 var Result;
 ((Result2) => {
@@ -165,6 +110,137 @@ 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/Core/Combinable.ts
+var Combinable;
+((Combinable2) => {
+  Combinable2.string = {
+    empty: "",
+    combine: (b) => (a) => a + b
+  };
+  Combinable2.sum = {
+    empty: 0,
+    combine: (b) => (a) => a + b
+  };
+  Combinable2.product = {
+    empty: 1,
+    combine: (b) => (a) => a * b
+  };
+  Combinable2.all = {
+    empty: true,
+    combine: (b) => (a) => a && b
+  };
+  Combinable2.any = {
+    empty: false,
+    combine: (b) => (a) => a || b
+  };
+  Combinable2.array = () => ({
+    empty: [],
+    combine: (b) => (a) => [...a, ...b]
+  });
+  Combinable2.maybe = (inner) => ({
+    empty: Maybe.none(),
+    combine: (b) => (a) => Maybe.isNone(a) ? b : Maybe.isNone(b) ? a : Maybe.some(inner.combine(b.value)(a.value))
+  });
+  Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
+})(Combinable || (Combinable = {}));
+
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  Deferred2.fromPromise = (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)) }
+  );
+  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+})(Deferred || (Deferred = {}));
+
+// src/Core/Equality.ts
+var Equality;
+((Equality2) => {
+  Equality2.string = (a, b) => a === b;
+  Equality2.number = (a, b) => a === b;
+  Equality2.boolean = (a, b) => a === b;
+  Equality2.date = (a, b) => a.getTime() === b.getTime();
+  Equality2.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
+  Equality2.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
+  Equality2.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
+})(Equality || (Equality = {}));
+
+// src/Core/Lazy.ts
+var Lazy;
+((Lazy2) => {
+  Lazy2.from = (f) => {
+    let done = false;
+    let cache;
+    return {
+      get: () => {
+        if (!done) {
+          cache = f();
+          done = true;
+        }
+        return cache;
+      }
+    };
+  };
+  Lazy2.evaluate = (lazy) => lazy.get();
+  Lazy2.map = (f) => (lazy) => Lazy2.from(() => f(lazy.get()));
+  Lazy2.chain = (f) => (lazy) => Lazy2.from(() => f(lazy.get()).get());
+  Lazy2.tap = (f) => (lazy) => Lazy2.from(() => {
+    const v = lazy.get();
+    f(v);
+    return v;
+  });
+})(Lazy || (Lazy = {}));
+
+// src/Core/Lens.ts
+var Lens;
+((Lens2) => {
+  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
+  Lens2.prop = () => (key) => (0, Lens2.make)(
+    (s) => s[key],
+    (a) => (s) => ({ ...s, [key]: a })
+  );
+  Lens2.get = (lens) => (s) => lens.get(s);
+  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
+  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
+  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)(
+    (s) => inner.get(outer.get(s)),
+    (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  );
+  Lens2.andThenOptional = (inner) => (outer) => ({
+    get: (s) => inner.get(outer.get(s)),
+    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  });
+  Lens2.toOptional = (lens) => ({
+    get: (s) => ({ kind: "Some", value: lens.get(s) }),
+    set: lens.set
+  });
+})(Lens || (Lens = {}));
+
+// src/Core/Logged.ts
+var Logged;
+((Logged2) => {
+  Logged2.make = (value) => ({ value, log: [] });
+  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
+  Logged2.map = (f) => (data) => ({
+    value: f(data.value),
+    log: data.log
+  });
+  Logged2.chain = (f) => (data) => {
+    const next = f(data.value);
+    return { value: next.value, log: [...data.log, ...next.log] };
+  };
+  Logged2.ap = (arg) => (data) => ({
+    value: data.value(arg.value),
+    log: [...data.log, ...arg.log]
+  });
+  Logged2.tap = (f) => (data) => {
+    f(data.value);
+    return data;
+  };
+  Logged2.run = (data) => [data.value, data.log];
+})(Logged || (Logged = {}));
+
 // src/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -1067,10 +1143,6 @@ var Op;
   Op2.wire = (source, f) => source.subscribe((state) => {
     if ((0, Op2.isOk)(state)) f(state.value);
   });
-  Op2.wireAll = (...pairs) => {
-    const cleanups = pairs.map(([source, f]) => (0, Op2.wire)(source, f));
-    return () => cleanups.forEach((c) => c());
-  };
   function interpret(op, options) {
     const { strategy, retry: retryOptions, timeout: timeoutOptions } = options;
     switch (strategy) {
@@ -1171,6 +1243,20 @@ var Optional;
   );
 })(Optional || (Optional = {}));
 
+// src/Core/Ordering.ts
+var Ordering;
+((Ordering2) => {
+  Ordering2.string = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  Ordering2.number = (a, b) => a - b;
+  Ordering2.date = (a, b) => a.getTime() - b.getTime();
+  Ordering2.reverse = (ord) => (a, b) => ord(b, a);
+  Ordering2.thenBy = (ord2) => (ord1) => (a, b) => {
+    const r = ord1(a, b);
+    return r !== 0 ? r : ord2(a, b);
+  };
+  Ordering2.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
+})(Ordering || (Ordering = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -1309,58 +1395,135 @@ var Task;
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    (signal) => new Promise(
-      (resolve2) => setTimeout(
-        () => toPromise(data, signal).then(resolve2),
-        ms
-      )
-    )
+    (signal) => new Promise((resolve2) => {
+      let timerId = void 0;
+      const onAbort = () => {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        resolve2(toPromise(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return resolve2(toPromise(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve2(toPromise(data, signal));
+      }, ms);
+    })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
     const { times, delay: ms } = options;
     if (times <= 0) return Promise.resolve([]);
     const results = [];
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (left) => toPromise(task, signal).then((a) => {
-      results.push(a);
-      if (left <= 1) return results;
-      return wait().then(() => run2(left - 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, ms || 0);
+      });
+    };
+    const run2 = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) return results;
+        return wait().then(() => run2(left - 1));
+      });
+    };
     return run2(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms, maxAttempts } = options;
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (attempt) => toPromise(task, signal).then((a) => {
-      if (predicate(a)) return a;
-      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
-      return wait().then(() => run2(attempt + 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, ms || 0);
+      });
+    };
+    const run2 = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        return Promise.resolve(lastValue);
+      }
+      return toPromise(task, signal).then((a) => {
+        if (predicate(a)) return a;
+        if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+        if (signal?.aborted) return a;
+        return wait().then(() => run2(attempt + 1, a));
+      });
+    };
     return run2(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
       results.push(await toPromise(task, signal));
     }
     return results;
   });
   Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
-    const onOuterAbort = () => controller.abort();
-    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
     let timerId;
+    const cleanUp = () => {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
+    const onOuterAbort = () => {
+      cleanUp();
+      controller.abort();
+    };
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
     return Promise.race([
       toPromise(task, controller.signal).then((a) => {
-        clearTimeout(timerId);
-        outerSignal?.removeEventListener("abort", onOuterAbort);
+        cleanUp();
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
         timerId = setTimeout(() => {
           controller.abort();
-          outerSignal?.removeEventListener("abort", onOuterAbort);
+          cleanUp();
           resolve2(Result.error(onTimeout()));
         }, ms);
       })
@@ -1396,28 +1559,33 @@ var Resource;
     release
   });
   Resource2.use = (f) => (resource) => Task.from(
-    () => Deferred.toPromise(resource.acquire()).then(async (acquired) => {
+    (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
       if (Result.isError(acquired)) return acquired;
       const a = acquired.value;
-      const usageResult = await Deferred.toPromise(f(a)());
-      await Deferred.toPromise(resource.release(a)());
-      return usageResult;
+      try {
+        const usageResult = await Deferred.toPromise(f(a)(signal));
+        return usageResult;
+      } finally {
+        await Deferred.toPromise(resource.release(a)(signal));
+      }
     })
   );
   Resource2.combine = (resourceA, resourceB) => ({
     acquire: Task.from(
-      () => Deferred.toPromise(resourceA.acquire()).then(async (acquiredA) => {
+      (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
         if (Result.isError(acquiredA)) return acquiredA;
         const a = acquiredA.value;
-        const acquiredB = await Deferred.toPromise(resourceB.acquire());
+        const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
         if (Result.isError(acquiredB)) {
-          await Deferred.toPromise(resourceA.release(a)());
+          await Deferred.toPromise(resourceA.release(a)(signal));
           return acquiredB;
         }
         return Result.ok([a, acquiredB.value]);
       })
     ),
-    release: ([a, b]) => Task.from(() => Deferred.toPromise(resourceB.release(b)()).then(() => Deferred.toPromise(resourceA.release(a)())))
+    release: ([a, b]) => Task.from(
+      (signal) => Deferred.toPromise(resourceB.release(b)(signal)).then(() => Deferred.toPromise(resourceA.release(a)(signal)))
+    )
   });
 })(Resource || (Resource = {}));
 
@@ -1460,14 +1628,14 @@ var TaskMaybe;
   TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
   TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
   TaskMaybe2.tryCatch = (f) => Task.from(
-    () => f().then(Maybe.some).catch(() => Maybe.none())
+    (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(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
+    (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);
@@ -1501,6 +1669,12 @@ var TaskResult;
   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) => Deferred.toPromise(task(signal));
 })(TaskResult || (TaskResult = {}));
 
@@ -1574,13 +1748,13 @@ var TaskValidation;
   TaskValidation2.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
   TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
   TaskValidation2.tryCatch = (f, onError) => Task.from(
-    () => f().then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
+    (signal) => f(signal).then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
   );
   TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
   TaskValidation2.ap = (arg) => (data) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
+    (signal) => Promise.all([
+      Deferred.toPromise(data(signal)),
+      Deferred.toPromise(arg(signal))
     ]).then(([vf, va]) => Validation.ap(va)(vf))
   );
   TaskValidation2.fold = (onInvalid, onValid) => (data) => Task.map(Validation.fold(onInvalid, onValid))(data);
@@ -1591,13 +1765,13 @@ var TaskValidation;
     (validation) => Validation.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
   TaskValidation2.product = (first, second) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(first()),
-      Deferred.toPromise(second())
+    (signal) => Promise.all([
+      Deferred.toPromise(first(signal)),
+      Deferred.toPromise(second(signal))
     ]).then(([va, vb]) => Validation.product(va, vb))
   );
   TaskValidation2.productAll = (data) => Task.from(
-    () => Promise.all(data.map((t) => Deferred.toPromise(t()))).then((results) => Validation.productAll(results))
+    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then((results) => Validation.productAll(results))
   );
 })(TaskValidation || (TaskValidation = {}));
 
@@ -1684,12 +1858,16 @@ var Tuple;
 })(Tuple || (Tuple = {}));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Combinable,
   Deferred,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Maybe,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,

package/dist/core.mjs

@@ -1,8 +1,12 @@
 import {
+  Combinable,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,
@@ -15,20 +19,24 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-PV7JOUKL.mjs";
+} from "./chunk-L3NC44SN.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-TK5ZCGP2.mjs";
 export {
+  Combinable,
   Deferred,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Maybe,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,

package/dist/index.d.mts

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

package/dist/index.d.ts

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