@nlozgachev/pipelined 0.31.0 → 0.32.0

package/dist/index.js

@@ -22,14 +22,18 @@ var src_exports = {};
 __export(src_exports, {
   Arr: () => Arr,
   Brand: () => Brand,
+  Combinable: () => Combinable,
   Deferred: () => Deferred,
   Dict: () => Dict,
+  Equality: () => Equality,
+  Lazy: () => Lazy,
   Lens: () => Lens,
   Logged: () => Logged,
   Maybe: () => Maybe,
   Num: () => Num,
   Op: () => Op,
   Optional: () => Optional,
+  Ordering: () => Ordering,
   Predicate: () => Predicate,
   Reader: () => Reader,
   Rec: () => Rec,
@@ -288,65 +292,6 @@ function uncurry(f) {
 var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
 var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
 
-// 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) => {
@@ -410,6 +355,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" };
@@ -1412,6 +1488,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) => {
@@ -1550,58 +1640,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);
       })
@@ -1637,28 +1804,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 = {}));
 
@@ -1701,14 +1873,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);
@@ -1742,6 +1914,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 = {}));
 
@@ -1815,13 +1993,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);
@@ -1832,13 +2010,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 = {}));
 
@@ -2015,11 +2193,25 @@ var Arr;
     }
     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);
@@ -2052,7 +2244,23 @@ var Arr;
     }
     return result;
   };
-  Arr2.flatten = (data) => [].concat(...data);
+  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 = [];
@@ -2291,8 +2499,8 @@ var Num;
     }
     return result;
   };
-  Num2.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
-  Num2.between = (min, max) => (n) => n >= min && n <= max;
+  Num2.clamp = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
+  Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
   Num2.parse = (s) => {
     if (s.trim() === "") return Maybe.none();
     const n = Number(s);
@@ -2308,6 +2516,28 @@ var Num;
   Num2.floor = (n) => Math.floor(n);
   Num2.ceil = (n) => Math.ceil(n);
   Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.none() : Maybe.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.none() : Maybe.some((0, Num2.sum)(ns) / ns.length);
+  Num2.min = (ns) => {
+    if (ns.length === 0) return Maybe.none();
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] < result) result = ns[i];
+    }
+    return Maybe.some(result);
+  };
+  Num2.max = (ns) => {
+    if (ns.length === 0) return Maybe.none();
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] > result) result = ns[i];
+    }
+    return Maybe.some(result);
+  };
 })(Num || (Num = {}));
 
 // src/Utils/Rec.ts
@@ -2431,6 +2661,7 @@ var Str;
   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.isEmpty = (s) => s.length === 0;
@@ -2548,14 +2779,18 @@ var Uniq;
 0 && (module.exports = {
   Arr,
   Brand,
+  Combinable,
   Deferred,
   Dict,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Maybe,
   Num,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Rec,

package/dist/index.mjs

@@ -28,10 +28,14 @@ import {
   uncurry4
 } from "./chunk-NRF2FVPZ.mjs";
 import {
+  Combinable,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,
@@ -44,7 +48,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-VIC54JR4.mjs";
+} from "./chunk-L3NC44SN.mjs";
 import {
   Arr,
   Dict,
@@ -52,13 +56,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-FWYOEWJ2.mjs";
+} from "./chunk-EHQFUWZW.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-TK5ZCGP2.mjs";
 import {
   Brand
 } from "./chunk-BYWKZLHM.mjs";
@@ -68,14 +72,18 @@ import {
 export {
   Arr,
   Brand,
+  Combinable,
   Deferred,
   Dict,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Maybe,
   Num,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Rec,