@nlozgachev/pipelined 0.32.0 → 0.34.0

package/dist/core.js

@@ -51,35 +51,48 @@ module.exports = __toCommonJS(Core_exports);
 var Result;
 ((Result2) => {
   Result2.ok = (value) => ({ kind: "Ok", value });
-  Result2.error = (e) => ({ kind: "Error", error: e });
+  Result2.err = (e) => ({ kind: "Err", error: e });
   Result2.isOk = (data) => data.kind === "Ok";
-  Result2.isError = (data) => data.kind === "Error";
+  Result2.isErr = (data) => data.kind === "Err";
   Result2.tryCatch = (f, onError) => {
     try {
       return (0, Result2.ok)(f());
-    } catch (e) {
-      return (0, Result2.error)(onError(e));
+    } catch (error) {
+      return (0, Result2.err)(onError(error));
     }
   };
   Result2.map = (f) => (data) => (0, Result2.isOk)(data) ? (0, Result2.ok)(f(data.value)) : data;
-  Result2.mapError = (f) => (data) => (0, Result2.isError)(data) ? (0, Result2.error)(f(data.error)) : data;
+  Result2.mapError = (f) => (data) => (0, Result2.isErr)(data) ? (0, Result2.err)(f(data.error)) : data;
   Result2.chain = (f) => (data) => (0, Result2.isOk)(data) ? f(data.value) : data;
   Result2.fold = (onErr, onOk) => (data) => (0, Result2.isOk)(data) ? onOk(data.value) : onErr(data.error);
   Result2.match = (cases) => (data) => (0, Result2.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
   Result2.getOrElse = (defaultValue) => (data) => (0, Result2.isOk)(data) ? data.value : defaultValue();
   Result2.tap = (f) => (data) => {
-    if ((0, Result2.isOk)(data)) f(data.value);
+    if ((0, Result2.isOk)(data)) {
+      f(data.value);
+    }
     return data;
   };
   Result2.tapError = (f) => (data) => {
-    if ((0, Result2.isError)(data)) f(data.error);
+    if ((0, Result2.isErr)(data)) {
+      f(data.error);
+    }
     return data;
   };
-  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
+  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
+  Result2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result2.err)(onNull()) : (0, Result2.ok)(value);
+  Result2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result2.err)(onNone()) : (0, Result2.ok)(maybe.value);
+  Result2.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result2.ok)(f(...args));
+    } catch (error) {
+      return (0, Result2.err)(onError(error));
+    }
+  };
   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.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
-  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isError)(data) ? data : arg;
+  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -94,7 +107,7 @@ var Maybe;
   Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
   Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
   Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
-  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.error(onNone());
+  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
   Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
   Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
   Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
@@ -102,7 +115,9 @@ var Maybe;
   Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
   Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
   Maybe2.tap = (f) => (data) => {
-    if ((0, Maybe2.isSome)(data)) f(data.value);
+    if ((0, Maybe2.isSome)(data)) {
+      f(data.value);
+    }
     return data;
   };
   Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
@@ -113,30 +128,12 @@ var 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.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))
@@ -196,17 +193,11 @@ var Lazy;
 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.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.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)
@@ -241,6 +232,31 @@ var Logged;
   Logged2.run = (data) => [data.value, data.log];
 })(Logged || (Logged = {}));
 
+// 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/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -249,11 +265,15 @@ var _evictedNil = { kind: "OpNil", reason: "evicted" };
 var _idle = { kind: "Idle" };
 var _pending = { kind: "Pending" };
 var ok = (value) => ({ kind: "OpOk", value });
-var err = (error) => ({ kind: "OpError", error });
-var cancellableWait = (ms, signal) => {
-  if (ms <= 0) return Promise.resolve();
+var err = (error) => ({ kind: "OpErr", error });
+var getMs = (duration) => Duration.toMilliseconds(duration);
+var cancellableWait = (duration, signal) => {
+  const rawMs = getMs(duration);
+  if (rawMs <= 0) {
+    return Promise.resolve();
+  }
   return new Promise((resolve) => {
-    const id = setTimeout(resolve, ms);
+    const id = setTimeout(resolve, rawMs);
     signal.addEventListener("abort", () => {
       clearTimeout(id);
       resolve();
@@ -262,23 +282,41 @@ var cancellableWait = (ms, signal) => {
 };
 var runWithRetry = (op, input, signal, options, onRetrying) => {
   const { attempts, backoff, when: shouldRetry } = options;
-  const getDelay = (n) => backoff === void 0 ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
+  const getDelay = (n) => {
+    if (backoff === void 0) {
+      return void 0;
+    }
+    return typeof backoff === "function" ? backoff(n) : backoff;
+  };
   const attempt = async (left) => {
     const result = await Deferred.toPromise(op._factory(input, signal));
-    if (result === null || signal.aborted) return null;
-    if (result.kind === "Ok") return result;
-    if (left <= 1) return result;
-    if (shouldRetry !== void 0 && !shouldRetry(result.error)) return result;
+    if (result === null || signal.aborted) {
+      return null;
+    }
+    if (result.kind === "Ok") {
+      return result;
+    }
+    if (left <= 1) {
+      return result;
+    }
+    if (shouldRetry !== void 0 && !shouldRetry(result.error)) {
+      return result;
+    }
     const attemptNumber = attempts - left + 1;
-    const ms = getDelay(attemptNumber);
+    const delayDuration = getDelay(attemptNumber);
+    const ms = delayDuration ? getMs(delayDuration) : 0;
     onRetrying({
       kind: "Retrying",
       attempt: attemptNumber,
       lastError: result.error,
       ...ms > 0 ? { nextRetryIn: ms } : {}
     });
-    await cancellableWait(ms, signal);
-    if (signal.aborted) return null;
+    if (delayDuration) {
+      await cancellableWait(delayDuration, signal);
+    }
+    if (signal.aborted) {
+      return null;
+    }
     return attempt(left - 1);
   };
   return attempt(attempts);
@@ -287,7 +325,9 @@ var execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying)
   const { signal } = controller;
   const toOutcome = (r) => r === null ? _abortedNil : r.kind === "Ok" ? ok(r.value) : err(r.error);
   const runPromise = retryOptions !== void 0 && onRetrying !== void 0 ? runWithRetry(op, input, signal, retryOptions, onRetrying).then(toOutcome) : Deferred.toPromise(op._factory(input, signal)).then(toOutcome);
-  if (timeoutOptions === void 0) return Deferred.fromPromise(runPromise);
+  if (timeoutOptions === void 0) {
+    return Deferred.fromPromise(runPromise);
+  }
   let timerId;
   return Deferred.fromPromise(Promise.race([
     runPromise.then((outcome) => {
@@ -298,7 +338,7 @@ var execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying)
       timerId = setTimeout(() => {
         controller.abort();
         resolve(err(timeoutOptions.onTimeout()));
-      }, timeoutOptions.ms);
+      }, getMs(timeoutOptions.duration));
     })
   ]));
 };
@@ -324,14 +364,20 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
       const controller = currentController;
       prev?.(_replacedNil);
       const startExecution = () => {
-        if (currentController !== controller) return;
+        if (currentController !== controller) {
+          return;
+        }
         lastStartTime = Date.now();
         emit(_pending);
         const onRetrying = retryOptions ? (r) => {
-          if (currentController === controller) emit(r);
+          if (currentController === controller) {
+            emit(r);
+          }
         } : void 0;
         execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-          if (currentController !== controller) return;
+          if (currentController !== controller) {
+            return;
+          }
           const r = currentResolve;
           currentResolve = void 0;
           currentController = void 0;
@@ -339,12 +385,14 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
           r?.(outcome);
         });
       };
-      const gap = minInterval !== void 0 ? Math.max(0, minInterval - (Date.now() - lastStartTime)) : 0;
+      const gap = minInterval !== void 0 ? Math.max(0, getMs(minInterval) - (Date.now() - lastStartTime)) : 0;
       if (gap > 0) {
         waitController = new AbortController();
         const wc = waitController;
-        cancellableWait(gap, wc.signal).then(() => {
-          if (waitController === wc) waitController = void 0;
+        cancellableWait(Duration.milliseconds(gap), wc.signal).then(() => {
+          if (waitController === wc) {
+            waitController = void 0;
+          }
           startExecution();
         });
       } else {
@@ -359,7 +407,9 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
     currentController = void 0;
     const r = currentResolve;
     currentResolve = void 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     r?.(_abortedNil);
   };
   return {
@@ -370,13 +420,15 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -402,19 +454,26 @@ var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
         const controller = currentController;
         emit(_pending);
         const onRetrying = retryOptions ? (r) => {
-          if (currentController === controller) emit(r);
+          if (currentController === controller) {
+            emit(r);
+          }
         } : void 0;
         execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-          if (currentController !== controller) return;
+          if (currentController !== controller) {
+            return;
+          }
           const r = currentResolve;
           currentResolve = void 0;
           currentController = void 0;
           emit(outcome);
           r?.(outcome);
-          if (cooldown !== void 0 && cooldown > 0) {
-            cooldownTimer = setTimeout(() => {
-              cooldownTimer = void 0;
-            }, cooldown);
+          if (cooldown !== void 0) {
+            const rawCooldown = getMs(cooldown);
+            if (rawCooldown > 0) {
+              cooldownTimer = setTimeout(() => {
+                cooldownTimer = void 0;
+              }, rawCooldown);
+            }
           }
         });
       })
@@ -429,7 +488,9 @@ var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
     currentController = void 0;
     const r = currentResolve;
     currentResolve = void 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     r?.(_abortedNil);
   };
   return {
@@ -440,13 +501,15 @@ var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -471,12 +534,16 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
     inflightResolvers.push(resolve);
     emit(_pending);
     const onRetrying = retryOptions ? (r) => {
-      if (generation === myGeneration && inflightControllers.has(controller)) emit(r);
+      if (generation === myGeneration && inflightControllers.has(controller)) {
+        emit(r);
+      }
     } : void 0;
     execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
       inflightControllers.delete(controller);
       const idx = inflightResolvers.indexOf(resolve);
-      if (idx !== -1) inflightResolvers.splice(idx, 1);
+      if (idx !== -1) {
+        inflightResolvers.splice(idx, 1);
+      }
       if (generation !== myGeneration) {
         resolve(_abortedNil);
         return;
@@ -533,7 +600,9 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
     const toResolve = inflightResolvers.splice(0);
     const queuedResolvers = queue.splice(0).map((item) => item.resolve);
     inFlight = 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     toResolve.forEach((r) => r(_abortedNil));
     queuedResolvers.forEach((r) => r(_abortedNil));
   };
@@ -545,13 +614,15 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -573,10 +644,14 @@ var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
     const controller = currentController;
     emit(_pending);
     const onRetrying = retryOptions ? (r) => {
-      if (currentController === controller) emit(r);
+      if (currentController === controller) {
+        emit(r);
+      }
     } : void 0;
     execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-      if (currentController !== controller) return;
+      if (currentController !== controller) {
+        return;
+      }
       const r = currentResolve;
       currentResolve = void 0;
       currentController = void 0;
@@ -609,7 +684,9 @@ var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
     const cr = currentResolve;
     currentResolve = void 0;
     const bufferedResolvers = buffer.splice(0).map((item) => item.resolve);
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     cr?.(_abortedNil);
     bufferedResolvers.forEach((r) => r(_abortedNil));
   };
@@ -621,18 +698,20 @@ var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
 };
-var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) => {
+var makeDebounced = (op, duration, leading, maxWait, retryOptions, timeoutOptions) => {
   let currentState = _idle;
   let currentController;
   let currentResolve;
@@ -653,10 +732,14 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
     leadingResolve = resolve;
     emit(_pending);
     const onRetrying = retryOptions ? (r) => {
-      if (leadingController === controller) emit(r);
+      if (leadingController === controller) {
+        emit(r);
+      }
     } : void 0;
     execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-      if (leadingController !== controller) return;
+      if (leadingController !== controller) {
+        return;
+      }
       const r = leadingResolve;
       leadingResolve = void 0;
       leadingController = void 0;
@@ -669,7 +752,9 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
     firstCallAt = 0;
     const capturedResolve = pendingResolve;
     pendingResolve = void 0;
-    if (capturedResolve === void 0) return;
+    if (capturedResolve === void 0) {
+      return;
+    }
     currentResolve = capturedResolve;
     const toRun = pendingInput;
     pendingInput = void 0;
@@ -677,10 +762,14 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
     const controller = currentController;
     emit(_pending);
     const onRetrying = retryOptions ? (r) => {
-      if (currentController === controller) emit(r);
+      if (currentController === controller) {
+        emit(r);
+      }
     } : void 0;
     execute(op, toRun, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-      if (currentController !== controller) return;
+      if (currentController !== controller) {
+        return;
+      }
       const r = currentResolve;
       currentResolve = void 0;
       currentController = void 0;
@@ -689,11 +778,13 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
     });
   };
   const scheduleTrailing = () => {
-    if (timerId !== void 0) clearTimeout(timerId);
-    let delay = ms;
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    let delay = getMs(duration);
     if (maxWait !== void 0 && firstCallAt > 0) {
-      const maxDelay = firstCallAt + maxWait - Date.now();
-      delay = Math.min(ms, Math.max(0, maxDelay));
+      const maxDelay = firstCallAt + getMs(maxWait) - Date.now();
+      delay = Math.min(getMs(duration), Math.max(0, maxDelay));
     }
     timerId = setTimeout(fireTrailing, delay);
   };
@@ -736,7 +827,9 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
     leadingResolve = void 0;
     leadingController?.abort();
     leadingController = void 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     pr?.(_abortedNil);
     cr?.(_abortedNil);
     lr?.(_abortedNil);
@@ -749,18 +842,20 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
 };
-var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
+var makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) => {
   let currentState = _idle;
   let currentController;
   let currentResolve;
@@ -778,10 +873,14 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
     const controller = currentController;
     emit(_pending);
     const onRetrying = retryOptions ? (r) => {
-      if (currentController === controller) emit(r);
+      if (currentController === controller) {
+        emit(r);
+      }
     } : void 0;
     execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-      if (currentController !== controller) return;
+      if (currentController !== controller) {
+        return;
+      }
       const r = currentResolve;
       currentResolve = void 0;
       currentController = void 0;
@@ -800,7 +899,7 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
         fireOp(input, resolve);
         startCooldown();
       }
-    }, ms);
+    }, getMs(duration));
   };
   const run = (input) => {
     if (cooldownTimer !== void 0) {
@@ -835,7 +934,9 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
     const pr = pendingResolve;
     pendingResolve = void 0;
     pendingInput = void 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     cr?.(_abortedNil);
     pr?.(_abortedNil);
   };
@@ -847,13 +948,15 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -877,12 +980,16 @@ var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
     inflightResolvers.push(resolve);
     emit(_pending);
     const onRetrying = retryOptions ? (r) => {
-      if (generation === myGeneration && controllers.has(controller)) emit(r);
+      if (generation === myGeneration && controllers.has(controller)) {
+        emit(r);
+      }
     } : void 0;
     execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
       controllers.delete(controller);
       const idx = inflightResolvers.indexOf(resolve);
-      if (idx !== -1) inflightResolvers.splice(idx, 1);
+      if (idx !== -1) {
+        inflightResolvers.splice(idx, 1);
+      }
       if (generation !== myGeneration) {
         resolve(_abortedNil);
         return;
@@ -922,7 +1029,9 @@ var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
     const toResolve = inflightResolvers.splice(0);
     const queuedResolvers = overflowQueue.splice(0).map((item) => item.resolve);
     inflight = 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     toResolve.forEach((r) => r(_abortedNil));
     queuedResolvers.forEach((r) => r(_abortedNil));
   };
@@ -934,13 +1043,15 @@ var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -971,7 +1082,7 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
         slots.set(k, { controller, resolve });
         stateMap.set(k, _pending);
         emitSnapshot();
-        execute(op, input, controller, void 0, timeoutOptions, void 0).then((outcome) => {
+        execute(op, input, controller, void 0, timeoutOptions).then((outcome) => {
           const slot = slots.get(k);
           if (!slot || slot.controller !== controller) {
             resolve(_abortedNil);
@@ -1004,7 +1115,9 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
         stateMap.set(k, _abortedNil);
       }
       slots.clear();
-      if (toResolve.length > 0) emitSnapshot();
+      if (toResolve.length > 0) {
+        emitSnapshot();
+      }
       toResolve.forEach((r) => r(_abortedNil));
     }
   };
@@ -1016,7 +1129,9 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (stateMap.size > 0) cb(new Map(stateMap));
+      if (stateMap.size > 0) {
+        cb(new Map(stateMap));
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => {
@@ -1025,7 +1140,7 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
     },
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -1050,10 +1165,14 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
         const controller = currentController;
         emit(_pending);
         const onRetrying = retryOptions ? (r) => {
-          if (currentController === controller) emit(r);
+          if (currentController === controller) {
+            emit(r);
+          }
         } : void 0;
         execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
-          if (currentController !== controller) return;
+          if (currentController !== controller) {
+            return;
+          }
           const r = currentResolve;
           currentResolve = void 0;
           currentController = void 0;
@@ -1068,7 +1187,9 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
     currentController = void 0;
     const r = currentResolve;
     currentResolve = void 0;
-    if (currentState.kind !== "Idle") emit(_abortedNil);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
     r?.(_abortedNil);
   };
   return {
@@ -1079,13 +1200,15 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
     abort,
     subscribe: (cb) => {
       subscribers.add(cb);
-      if (currentState.kind !== "Idle") cb(currentState);
+      if (currentState.kind !== "Idle") {
+        cb(currentState);
+      }
       return () => subscribers.delete(cb);
     },
     reset: () => emit(_idle),
     poll: (input, { interval }) => {
       void run(input);
-      const id = setInterval(() => void run(input), interval);
+      const id = setInterval(() => void run(input), getMs(interval));
       return () => clearInterval(id);
     }
   };
@@ -1097,62 +1220,80 @@ var Op;
   Op2.nil = (reason) => ({ kind: "OpNil", reason });
   Op2.create = (factory, onError) => ({
     _factory: (input, signal) => Deferred.fromPromise(
-      factory(signal)(input).then((value) => Result.ok(value)).catch((e) => signal.aborted ? null : Result.error(onError(e)))
+      factory(signal)(input).then((value) => Result.ok(value)).catch(
+        (error) => signal.aborted ? null : Result.err(onError(error))
+      )
     )
   });
-  Op2.lift = (f) => (0, Op2.create)(
-    (signal) => (input) => f(input, signal),
-    (e) => e
-  );
+  Op2.lift = (f) => (0, Op2.create)((signal) => (input) => f(input, signal), (e) => e);
   Op2.ok = (value) => ({ kind: "OpOk", value });
-  Op2.error = (error2) => ({ kind: "OpError", error: error2 });
+  Op2.err = (error) => ({ kind: "OpErr", error });
   Op2.isIdle = (state) => state.kind === "Idle";
   Op2.isPending = (state) => state.kind === "Pending";
   Op2.isQueued = (state) => state.kind === "Queued";
   Op2.isRetrying = (state) => state.kind === "Retrying";
   Op2.isOk = (state) => state.kind === "OpOk";
-  Op2.isError = (state) => state.kind === "OpError";
+  Op2.isErr = (state) => state.kind === "OpErr";
   Op2.isNil = (state) => state.kind === "OpNil";
   Op2.match = (cases) => (outcome) => {
-    if (outcome.kind === "OpOk") return cases.ok(outcome.value);
-    if (outcome.kind === "OpError") return cases.error(outcome.error);
+    if (outcome.kind === "OpOk") {
+      return cases.ok(outcome.value);
+    }
+    if (outcome.kind === "OpErr") {
+      return cases.err(outcome.error);
+    }
     return cases.nil();
   };
-  Op2.fold = (onError, onOk, onNil) => (outcome) => {
-    if (outcome.kind === "OpOk") return onOk(outcome.value);
-    if (outcome.kind === "OpError") return onError(outcome.error);
+  Op2.fold = (onErr, onOk, onNil) => (outcome) => {
+    if (outcome.kind === "OpOk") {
+      return onOk(outcome.value);
+    }
+    if (outcome.kind === "OpErr") {
+      return onErr(outcome.error);
+    }
     return onNil();
   };
   Op2.getOrElse = (defaultValue) => (outcome) => outcome.kind === "OpOk" ? outcome.value : defaultValue();
   Op2.map = (f) => (outcome) => outcome.kind === "OpOk" ? (0, Op2.ok)(f(outcome.value)) : outcome;
-  Op2.mapError = (f) => (outcome) => outcome.kind === "OpError" ? (0, Op2.error)(f(outcome.error)) : outcome;
+  Op2.mapError = (f) => (outcome) => outcome.kind === "OpErr" ? (0, Op2.err)(f(outcome.error)) : outcome;
   Op2.chain = (f) => (outcome) => outcome.kind === "OpOk" ? f(outcome.value) : outcome;
   Op2.tap = (f) => (outcome) => {
-    if (outcome.kind === "OpOk") f(outcome.value);
+    if (outcome.kind === "OpOk") {
+      f(outcome.value);
+    }
     return outcome;
   };
-  Op2.recover = (f) => (outcome) => outcome.kind === "OpError" ? f(outcome.error) : outcome;
+  Op2.recover = (f) => (outcome) => outcome.kind === "OpErr" ? f(outcome.error) : outcome;
   Op2.toResult = (onNil) => (outcome) => {
-    if (outcome.kind === "OpOk") return Result.ok(outcome.value);
-    if (outcome.kind === "OpError") return Result.error(outcome.error);
-    return Result.error(onNil());
+    if (outcome.kind === "OpOk") {
+      return Result.ok(outcome.value);
+    }
+    if (outcome.kind === "OpErr") {
+      return Result.err(outcome.error);
+    }
+    return Result.err(onNil());
   };
   Op2.toMaybe = (outcome) => outcome.kind === "OpOk" ? Maybe.some(outcome.value) : Maybe.none();
   Op2.all = (invocations) => Deferred.fromPromise(Promise.all(invocations.map(Deferred.toPromise)));
   Op2.race = (invocations) => Deferred.fromPromise(Promise.race(invocations.map(Deferred.toPromise)));
   Op2.wire = (source, f) => source.subscribe((state) => {
-    if ((0, Op2.isOk)(state)) f(state.value);
+    if ((0, Op2.isOk)(state)) {
+      f(state.value);
+    }
   });
   function interpret(op, options) {
     const { strategy, retry: retryOptions, timeout: timeoutOptions } = options;
     switch (strategy) {
-      case "once":
+      case "once": {
         return makeOnce(op, retryOptions, timeoutOptions);
-      case "restartable":
+      }
+      case "restartable": {
         return makeRestartable(op, options.minInterval, retryOptions, timeoutOptions);
-      case "exclusive":
+      }
+      case "exclusive": {
         return makeExclusive(op, options.cooldown, retryOptions, timeoutOptions);
-      case "queue":
+      }
+      case "queue": {
         return makeQueue(
           op,
           options.maxSize,
@@ -1162,13 +1303,24 @@ var Op;
           retryOptions,
           timeoutOptions
         );
-      case "buffered":
+      }
+      case "buffered": {
         return makeBuffered(op, options.size, retryOptions, timeoutOptions);
-      case "debounced":
-        return makeDebounced(op, options.ms ?? 0, options.leading ?? false, options.maxWait, retryOptions, timeoutOptions);
-      case "throttled":
-        return makeThrottled(op, options.ms ?? 0, options.trailing ?? false, retryOptions, timeoutOptions);
-      case "concurrent":
+      }
+      case "debounced": {
+        return makeDebounced(
+          op,
+          options.duration,
+          options.leading ?? false,
+          options.maxWait,
+          retryOptions,
+          timeoutOptions
+        );
+      }
+      case "throttled": {
+        return makeThrottled(op, options.duration, options.trailing ?? false, retryOptions, timeoutOptions);
+      }
+      case "concurrent": {
         return makeConcurrent(
           op,
           options.n ?? 1,
@@ -1176,8 +1328,10 @@ var Op;
           retryOptions,
           timeoutOptions
         );
-      case "keyed":
+      }
+      case "keyed": {
         return makeKeyed(op, options.key ?? ((i) => i), options.perKey ?? "exclusive", timeoutOptions);
+      }
     }
   }
   Op2.interpret = interpret;
@@ -1187,22 +1341,18 @@ var Op;
 var Optional;
 ((Optional2) => {
   Optional2.make = (get2, set2) => ({ get: get2, set: set2 });
-  Optional2.prop = () => (key) => (0, Optional2.make)(
-    (s) => {
-      const val = s[key];
-      return val !== null && val !== void 0 ? Maybe.some(val) : Maybe.none();
-    },
-    (a) => (s) => ({ ...s, [key]: a })
-  );
-  Optional2.index = (i) => (0, Optional2.make)(
-    (arr) => i >= 0 && i < arr.length ? Maybe.some(arr[i]) : Maybe.none(),
-    (a) => (arr) => {
-      if (i < 0 || i >= arr.length) return arr;
-      const copy = [...arr];
-      copy[i] = a;
-      return copy;
+  Optional2.prop = () => (key) => (0, Optional2.make)((s) => {
+    const val = s[key];
+    return val !== null && val !== void 0 ? Maybe.some(val) : Maybe.none();
+  }, (a) => (s) => ({ ...s, [key]: a }));
+  Optional2.index = (i) => (0, Optional2.make)((arr) => i >= 0 && i < arr.length ? Maybe.some(arr[i]) : Maybe.none(), (a) => (arr) => {
+    if (i < 0 || i >= arr.length) {
+      return arr;
     }
-  );
+    const copy = [...arr];
+    copy[i] = a;
+    return copy;
+  });
   Optional2.get = (opt) => (s) => opt.get(s);
   Optional2.set = (opt) => (a) => (s) => opt.set(a)(s);
   Optional2.modify = (opt) => (f) => (s) => {
@@ -1221,26 +1371,20 @@ var Optional;
     const val = opt.get(s);
     return val.kind === "Some" ? cases.some(val.value) : cases.none();
   };
-  Optional2.andThen = (inner) => (outer) => (0, Optional2.make)(
-    (s) => {
-      const mid = outer.get(s);
-      return mid.kind === "None" ? Maybe.none() : inner.get(mid.value);
-    },
-    (b) => (s) => {
-      const mid = outer.get(s);
-      return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
-    }
-  );
-  Optional2.andThenLens = (inner) => (outer) => (0, Optional2.make)(
-    (s) => {
-      const mid = outer.get(s);
-      return mid.kind === "None" ? Maybe.none() : Maybe.some(inner.get(mid.value));
-    },
-    (b) => (s) => {
-      const mid = outer.get(s);
-      return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
-    }
-  );
+  Optional2.andThen = (inner) => (outer) => (0, Optional2.make)((s) => {
+    const mid = outer.get(s);
+    return mid.kind === "None" ? Maybe.none() : inner.get(mid.value);
+  }, (b) => (s) => {
+    const mid = outer.get(s);
+    return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
+  });
+  Optional2.andThenLens = (inner) => (outer) => (0, Optional2.make)((s) => {
+    const mid = outer.get(s);
+    return mid.kind === "None" ? Maybe.none() : Maybe.some(inner.get(mid.value));
+  }, (b) => (s) => {
+    const mid = outer.get(s);
+    return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
+  });
 })(Optional || (Optional = {}));
 
 // src/Core/Ordering.ts
@@ -1295,7 +1439,7 @@ var Refinement;
   Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
   Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
   Refinement2.toFilter = (r) => (a) => r(a) ? Maybe.some(a) : Maybe.none();
-  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.error(onFail(a));
+  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
 })(Refinement || (Refinement = {}));
 
 // src/Core/RemoteData.ts
@@ -1305,14 +1449,8 @@ var RemoteData;
 ((RemoteData2) => {
   RemoteData2.notAsked = () => _notAsked;
   RemoteData2.loading = () => _loading;
-  RemoteData2.failure = (error) => ({
-    kind: "Failure",
-    error
-  });
-  RemoteData2.success = (value) => ({
-    kind: "Success",
-    value
-  });
+  RemoteData2.failure = (error) => ({ kind: "Failure", error });
+  RemoteData2.success = (value) => ({ kind: "Success", value });
   RemoteData2.isNotAsked = (data) => data.kind === "NotAsked";
   RemoteData2.isLoading = (data) => data.kind === "Loading";
   RemoteData2.isFailure = (data) => data.kind === "Failure";
@@ -1324,47 +1462,65 @@ var RemoteData;
     if ((0, RemoteData2.isSuccess)(data) && (0, RemoteData2.isSuccess)(arg)) {
       return (0, RemoteData2.success)(data.value(arg.value));
     }
-    if ((0, RemoteData2.isFailure)(data)) return data;
-    if ((0, RemoteData2.isFailure)(arg)) return arg;
-    if ((0, RemoteData2.isLoading)(data) || (0, RemoteData2.isLoading)(arg)) return (0, RemoteData2.loading)();
+    if ((0, RemoteData2.isFailure)(data)) {
+      return data;
+    }
+    if ((0, RemoteData2.isFailure)(arg)) {
+      return arg;
+    }
+    if ((0, RemoteData2.isLoading)(data) || (0, RemoteData2.isLoading)(arg)) {
+      return (0, RemoteData2.loading)();
+    }
     return (0, RemoteData2.notAsked)();
   };
   RemoteData2.fold = (onNotAsked, onLoading, onFailure, onSuccess) => (data) => {
     switch (data.kind) {
-      case "NotAsked":
+      case "NotAsked": {
         return onNotAsked();
-      case "Loading":
+      }
+      case "Loading": {
         return onLoading();
-      case "Failure":
+      }
+      case "Failure": {
         return onFailure(data.error);
-      case "Success":
+      }
+      case "Success": {
         return onSuccess(data.value);
+      }
     }
   };
   RemoteData2.match = (cases) => (data) => {
     switch (data.kind) {
-      case "NotAsked":
+      case "NotAsked": {
         return cases.notAsked();
-      case "Loading":
+      }
+      case "Loading": {
         return cases.loading();
-      case "Failure":
+      }
+      case "Failure": {
         return cases.failure(data.error);
-      case "Success":
+      }
+      case "Success": {
         return cases.success(data.value);
+      }
     }
   };
   RemoteData2.getOrElse = (defaultValue) => (data) => (0, RemoteData2.isSuccess)(data) ? data.value : defaultValue();
   RemoteData2.tap = (f) => (data) => {
-    if ((0, RemoteData2.isSuccess)(data)) f(data.value);
+    if ((0, RemoteData2.isSuccess)(data)) {
+      f(data.value);
+    }
     return data;
   };
   RemoteData2.tapError = (f) => (data) => {
-    if ((0, RemoteData2.isFailure)(data)) f(data.error);
+    if ((0, RemoteData2.isFailure)(data)) {
+      f(data.error);
+    }
     return data;
   };
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
   RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
-  RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.error((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
+  RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
   RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
   RemoteData2.fromMaybe = (onNone) => (data) => Maybe.isSome(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(onNone());
   RemoteData2.filter = (pred, onFalse) => (data) => (0, RemoteData2.isSuccess)(data) ? pred(data.value) ? data : (0, RemoteData2.failure)(onFalse(data.value)) : data;
@@ -1372,6 +1528,7 @@ var RemoteData;
 
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs2 = (duration) => Duration.toMilliseconds(duration);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
@@ -1379,12 +1536,7 @@ var Task;
   Task2.fromSync = (f) => () => Deferred.fromPromise(Promise.resolve(f()));
   Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
   Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
-  Task2.ap = (arg) => (data) => (0, Task2.from)(
-    (signal) => Promise.all([
-      toPromise(data, signal),
-      toPromise(arg, signal)
-    ]).then(([f, a]) => f(a))
-  );
+  Task2.ap = (arg) => (data) => (0, Task2.from)((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
   Task2.tap = (f) => (data) => (0, Task2.from)(
     (signal) => toPromise(data, signal).then((a) => {
       f(a);
@@ -1394,35 +1546,39 @@ var Task;
   Task2.all = (tasks) => (0, Task2.from)(
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
-  Task2.delay = (ms) => (data) => (0, Task2.from)(
-    (signal) => new Promise((resolve2) => {
-      let timerId = void 0;
+  Task2.delay = (duration) => (data) => (0, Task2.from)(
+    (signal) => new Promise((res) => {
+      let timerId;
       const onAbort = () => {
         if (timerId !== void 0) {
           clearTimeout(timerId);
         }
-        resolve2(toPromise(data, signal));
+        res(toPromise(data, signal));
       };
       if (signal) {
         if (signal.aborted) {
-          return resolve2(toPromise(data, signal));
+          return res(toPromise(data, signal));
         }
         signal.addEventListener("abort", onAbort, { once: true });
       }
       timerId = setTimeout(() => {
         signal?.removeEventListener("abort", onAbort);
-        resolve2(toPromise(data, signal));
-      }, ms);
+        res(toPromise(data, signal));
+      }, getMs2(duration));
     })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
-    const { times, delay: ms } = options;
-    if (times <= 0) return Promise.resolve([]);
+    const { times, delay: delayDuration } = options;
+    if (times <= 0) {
+      return Promise.resolve([]);
+    }
     const results = [];
     const wait = () => {
-      if (signal?.aborted) return Promise.resolve();
+      if (signal?.aborted) {
+        return Promise.resolve();
+      }
       return new Promise((r) => {
-        let timerId = void 0;
+        let timerId;
         const onAbort = () => {
           if (timerId !== void 0) {
             clearTimeout(timerId);
@@ -1435,7 +1591,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, delayDuration ? getMs2(delayDuration) : 0);
       });
     };
     const run2 = (left) => {
@@ -1444,18 +1600,22 @@ var Task;
       }
       return toPromise(task, signal).then((a) => {
         results.push(a);
-        if (left <= 1 || signal?.aborted) return results;
+        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 { when: predicate, delay: delayDuration, maxAttempts } = options;
     const wait = () => {
-      if (signal?.aborted) return Promise.resolve();
+      if (signal?.aborted) {
+        return Promise.resolve();
+      }
       return new Promise((r) => {
-        let timerId = void 0;
+        let timerId;
         const onAbort = () => {
           if (timerId !== void 0) {
             clearTimeout(timerId);
@@ -1468,7 +1628,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, delayDuration ? getMs2(delayDuration) : 0);
       });
     };
     const run2 = (attempt, lastValue) => {
@@ -1476,15 +1636,55 @@ var Task;
         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;
+        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.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) {
@@ -1495,19 +1695,19 @@ var Task;
     }
     return results;
   });
-  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
+  Task2.timeout = (duration, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
     let timerId;
-    const cleanUp = () => {
+    function cleanUp() {
       if (timerId !== void 0) {
         clearTimeout(timerId);
       }
       outerSignal?.removeEventListener("abort", onOuterAbort);
-    };
-    const onOuterAbort = () => {
+    }
+    function onOuterAbort() {
       cleanUp();
       controller.abort();
-    };
+    }
     if (outerSignal) {
       if (outerSignal.aborted) {
         controller.abort();
@@ -1520,12 +1720,12 @@ var Task;
         cleanUp();
         return Result.ok(a);
       }),
-      new Promise((resolve2) => {
+      new Promise((res) => {
         timerId = setTimeout(() => {
           controller.abort();
           cleanUp();
-          resolve2(Result.error(onTimeout()));
-        }, ms);
+          res(Result.err(onTimeout()));
+        }, getMs2(duration));
       })
     ]);
   });
@@ -1553,14 +1753,19 @@ var Task;
 // src/Core/Resource.ts
 var Resource;
 ((Resource2) => {
-  Resource2.make = (acquire, release) => ({ acquire, release });
+  Resource2.make = (acquire, release) => ({
+    acquire,
+    release
+  });
   Resource2.fromTask = (acquire, release) => ({
     acquire: Task.map((a) => Result.ok(a))(acquire),
     release
   });
   Resource2.use = (f) => (resource) => Task.from(
     (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
-      if (Result.isError(acquired)) return acquired;
+      if (Result.isErr(acquired)) {
+        return acquired;
+      }
       const a = acquired.value;
       try {
         const usageResult = await Deferred.toPromise(f(a)(signal));
@@ -1573,10 +1778,12 @@ var Resource;
   Resource2.combine = (resourceA, resourceB) => ({
     acquire: Task.from(
       (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
-        if (Result.isError(acquiredA)) return acquiredA;
+        if (Result.isErr(acquiredA)) {
+          return acquiredA;
+        }
         const a = acquiredA.value;
         const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
-        if (Result.isError(acquiredB)) {
+        if (Result.isErr(acquiredB)) {
           await Deferred.toPromise(resourceA.release(a)(signal));
           return acquiredB;
         }
@@ -1626,17 +1833,16 @@ var TaskMaybe;
   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.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_))
+    (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);
@@ -1650,30 +1856,29 @@ var TaskMaybe;
 var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.error(error));
-  TaskResult2.tryCatch = (f, onError) => Task.from(
-    (signal) => f(signal).then(Result.ok).catch((e) => Result.error(onError(e)))
-  );
+  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) => 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.error(result.error))
-  )(
+  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.isError(result) ? fallback(result.error) : Task.resolve(result)
+    (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_))
+    (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 = {}));
@@ -1681,97 +1886,97 @@ var TaskResult;
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
-  Validation2.valid = (value) => ({
-    kind: "Valid",
-    value
-  });
-  Validation2.invalid = (error) => ({
-    kind: "Invalid",
-    errors: [error]
-  });
-  Validation2.invalidAll = (errors) => ({
-    kind: "Invalid",
-    errors
-  });
-  Validation2.isValid = (data) => data.kind === "Valid";
-  Validation2.isInvalid = (data) => data.kind === "Invalid";
-  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.valid)(a) : (0, Validation2.invalid)(onFalse(a));
-  Validation2.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : data;
+  Validation2.passed = (value) => ({ kind: "Passed", value });
+  Validation2.failed = (error) => ({ kind: "Failed", errors: [error] });
+  Validation2.failedAll = (errors) => ({ kind: "Failed", errors });
+  Validation2.isPassed = (data) => data.kind === "Passed";
+  Validation2.isFailed = (data) => data.kind === "Failed";
+  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.passed)(a) : (0, Validation2.failed)(onFalse(a));
+  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.failed)(onNull()) : (0, Validation2.passed)(value);
+  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.failed)(onNone()) : (0, Validation2.passed)(maybe.value);
+  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.isValid)(data) && (0, Validation2.isValid)(arg)) return (0, Validation2.valid)(data.value(arg.value));
-    const errors = [
-      ...(0, Validation2.isInvalid)(data) ? data.errors : [],
-      ...(0, Validation2.isInvalid)(arg) ? arg.errors : []
-    ];
-    return (0, Validation2.invalidAll)(errors);
-  };
-  Validation2.fold = (onInvalid, onValid) => (data) => (0, Validation2.isValid)(data) ? onValid(data.value) : onInvalid(data.errors);
-  Validation2.match = (cases) => (data) => (0, Validation2.isValid)(data) ? cases.valid(data.value) : cases.invalid(data.errors);
-  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isValid)(data) ? data.value : defaultValue();
+    if ((0, Validation2.isPassed)(data) && (0, Validation2.isPassed)(arg)) {
+      return (0, Validation2.passed)(data.value(arg.value));
+    }
+    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
+    return (0, Validation2.failedAll)(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);
+  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isPassed)(data) ? data.value : defaultValue();
   Validation2.tap = (f) => (data) => {
-    if ((0, Validation2.isValid)(data)) f(data.value);
+    if ((0, Validation2.isPassed)(data)) {
+      f(data.value);
+    }
     return data;
   };
   Validation2.tapError = (f) => (data) => {
-    if ((0, Validation2.isInvalid)(data)) f(data.errors);
+    if ((0, Validation2.isFailed)(data)) {
+      f(data.errors);
+    }
     return data;
   };
-  Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some(isBlocked) ? fallback() : data;
-  Validation2.toResult = (data) => (0, Validation2.isValid)(data) ? Result.ok(data.value) : Result.error(data.errors);
-  Validation2.toMaybe = (data) => (0, Validation2.isValid)(data) ? Maybe.some(data.value) : Maybe.none();
-  Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.valid)(data.value) : (0, Validation2.invalid)(data.error);
+  Validation2.recover = (fallback) => (data) => (0, Validation2.isPassed)(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isFailed)(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  Validation2.toResult = (data) => (0, Validation2.isPassed)(data) ? Result.ok(data.value) : Result.err(data.errors);
+  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.isValid)(first) && (0, Validation2.isValid)(second)) return (0, Validation2.valid)([first.value, second.value]);
-    const errors = [
-      ...(0, Validation2.isInvalid)(first) ? first.errors : [],
-      ...(0, Validation2.isInvalid)(second) ? second.errors : []
-    ];
-    return (0, Validation2.invalidAll)(errors);
+    if ((0, Validation2.isPassed)(first) && (0, Validation2.isPassed)(second)) {
+      return (0, Validation2.passed)([first.value, second.value]);
+    }
+    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
+    return (0, Validation2.failedAll)(errors);
   };
   Validation2.productAll = (data) => {
     const values = [];
     const errors = [];
     for (const v of data) {
-      if ((0, Validation2.isValid)(v)) values.push(v.value);
-      else errors.push(...v.errors);
+      if ((0, Validation2.isPassed)(v)) {
+        values.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
     }
-    return errors.length > 0 ? (0, Validation2.invalidAll)(errors) : (0, Validation2.valid)(values);
+    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
   };
 })(Validation || (Validation = {}));
 
 // src/Core/TaskValidation.ts
 var TaskValidation;
 ((TaskValidation2) => {
-  TaskValidation2.valid = (value) => Task.resolve(Validation.valid(value));
-  TaskValidation2.invalid = (error) => Task.resolve(Validation.invalid(error));
-  TaskValidation2.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
+  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.tryCatch = (f, onError) => Task.from(
-    (signal) => f(signal).then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
-  );
+  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))
+    (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);
+  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.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors)
+    (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))
+    (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))
+    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then(
+      (results) => Validation.productAll(results)
+    )
   );
 })(TaskValidation || (TaskValidation = {}));
 
@@ -1780,58 +1985,84 @@ var These;
 ((These2) => {
   These2.first = (value) => ({ kind: "First", first: value });
   These2.second = (value) => ({ kind: "Second", second: value });
-  These2.both = (first2, second2) => ({
-    kind: "Both",
-    first: first2,
-    second: second2
-  });
+  These2.both = (f, s) => ({ kind: "Both", first: f, second: s });
   These2.isFirst = (data) => data.kind === "First";
   These2.isSecond = (data) => data.kind === "Second";
   These2.isBoth = (data) => data.kind === "Both";
   These2.hasFirst = (data) => data.kind === "First" || data.kind === "Both";
   These2.hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
   These2.mapFirst = (f) => (data) => {
-    if ((0, These2.isSecond)(data)) return data;
-    if ((0, These2.isFirst)(data)) return (0, These2.first)(f(data.first));
+    if ((0, These2.isSecond)(data)) {
+      return data;
+    }
+    if ((0, These2.isFirst)(data)) {
+      return (0, These2.first)(f(data.first));
+    }
     return (0, These2.both)(f(data.first), data.second);
   };
   These2.mapSecond = (f) => (data) => {
-    if ((0, These2.isFirst)(data)) return data;
-    if ((0, These2.isSecond)(data)) return (0, These2.second)(f(data.second));
+    if ((0, These2.isFirst)(data)) {
+      return data;
+    }
+    if ((0, These2.isSecond)(data)) {
+      return (0, These2.second)(f(data.second));
+    }
     return (0, These2.both)(data.first, f(data.second));
   };
   These2.mapBoth = (onFirst, onSecond) => (data) => {
-    if ((0, These2.isSecond)(data)) return (0, These2.second)(onSecond(data.second));
-    if ((0, These2.isFirst)(data)) return (0, These2.first)(onFirst(data.first));
+    if ((0, These2.isSecond)(data)) {
+      return (0, These2.second)(onSecond(data.second));
+    }
+    if ((0, These2.isFirst)(data)) {
+      return (0, These2.first)(onFirst(data.first));
+    }
     return (0, These2.both)(onFirst(data.first), onSecond(data.second));
   };
   These2.chainFirst = (f) => (data) => {
-    if ((0, These2.isSecond)(data)) return data;
+    if ((0, These2.isSecond)(data)) {
+      return data;
+    }
     return f(data.first);
   };
   These2.chainSecond = (f) => (data) => {
-    if ((0, These2.isFirst)(data)) return data;
+    if ((0, These2.isFirst)(data)) {
+      return data;
+    }
     return f(data.second);
   };
   These2.fold = (onFirst, onSecond, onBoth) => (data) => {
-    if ((0, These2.isSecond)(data)) return onSecond(data.second);
-    if ((0, These2.isFirst)(data)) return onFirst(data.first);
+    if ((0, These2.isSecond)(data)) {
+      return onSecond(data.second);
+    }
+    if ((0, These2.isFirst)(data)) {
+      return onFirst(data.first);
+    }
     return onBoth(data.first, data.second);
   };
   These2.match = (cases) => (data) => {
-    if ((0, These2.isSecond)(data)) return cases.second(data.second);
-    if ((0, These2.isFirst)(data)) return cases.first(data.first);
+    if ((0, These2.isSecond)(data)) {
+      return cases.second(data.second);
+    }
+    if ((0, These2.isFirst)(data)) {
+      return cases.first(data.first);
+    }
     return cases.both(data.first, data.second);
   };
   These2.getFirstOrElse = (defaultValue) => (data) => (0, These2.hasFirst)(data) ? data.first : defaultValue();
   These2.getSecondOrElse = (defaultValue) => (data) => (0, These2.hasSecond)(data) ? data.second : defaultValue();
   These2.tap = (f) => (data) => {
-    if ((0, These2.hasFirst)(data)) f(data.first);
+    if ((0, These2.hasFirst)(data)) {
+      f(data.first);
+    }
     return data;
   };
   These2.swap = (data) => {
-    if ((0, These2.isSecond)(data)) return (0, These2.first)(data.second);
-    if ((0, These2.isFirst)(data)) return (0, These2.second)(data.first);
+    if ((0, These2.isSecond)(data)) {
+      return (0, These2.first)(data.second);
+    }
+    if ((0, These2.isFirst)(data)) {
+      return (0, These2.second)(data.first);
+    }
     return (0, These2.both)(data.second, data.first);
   };
 })(These || (These = {}));