@nlozgachev/pipelined 0.33.0 → 0.34.0

package/dist/{chunk-FZX4MTRI.mjs → chunk-5AWUAG7G.mjs}

@@ -3,35 +3,20 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-GSTKY7MF.mjs";
+} from "./chunk-DLBHVYII.mjs";
+import {
+  Duration
+} from "./chunk-VWVPHDZO.mjs";
 
 // 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))
@@ -81,17 +66,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)
@@ -134,11 +113,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();
@@ -147,23 +130,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);
@@ -172,7 +173,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) => {
@@ -183,7 +186,7 @@ var execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying)
       timerId = setTimeout(() => {
         controller.abort();
         resolve(err(timeoutOptions.onTimeout()));
-      }, timeoutOptions.ms);
+      }, getMs(timeoutOptions.duration));
     })
   ]));
 };
@@ -209,14 +212,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;
@@ -224,12 +233,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 {
@@ -244,7 +255,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 {
@@ -255,13 +268,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);
     }
   };
@@ -287,19 +302,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);
+            }
           }
         });
       })
@@ -314,7 +336,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 {
@@ -325,13 +349,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);
     }
   };
@@ -356,12 +382,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;
@@ -418,7 +448,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));
   };
@@ -430,13 +462,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);
     }
   };
@@ -458,10 +492,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;
@@ -494,7 +532,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));
   };
@@ -506,18 +546,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;
@@ -538,10 +580,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;
@@ -554,7 +600,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;
@@ -562,10 +610,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;
@@ -574,11 +626,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);
   };
@@ -621,7 +675,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);
@@ -634,18 +690,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;
@@ -663,10 +721,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;
@@ -685,7 +747,7 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
         fireOp(input, resolve);
         startCooldown();
       }
-    }, ms);
+    }, getMs(duration));
   };
   const run = (input) => {
     if (cooldownTimer !== void 0) {
@@ -720,7 +782,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);
   };
@@ -732,13 +796,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);
     }
   };
@@ -762,12 +828,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;
@@ -807,7 +877,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));
   };
@@ -819,13 +891,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);
     }
   };
@@ -856,7 +930,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);
@@ -889,7 +963,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));
     }
   };
@@ -901,7 +977,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: () => {
@@ -910,7 +988,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);
     }
   };
@@ -935,10 +1013,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;
@@ -953,7 +1035,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 {
@@ -964,13 +1048,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);
     }
   };
@@ -982,62 +1068,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,
@@ -1047,13 +1151,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,
@@ -1061,8 +1176,10 @@ var Op;
           retryOptions,
           timeoutOptions
         );
-      case "keyed":
+      }
+      case "keyed": {
         return makeKeyed(op, options.key ?? ((i) => i), options.perKey ?? "exclusive", timeoutOptions);
+      }
     }
   }
   Op2.interpret = interpret;
@@ -1072,22 +1189,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) => {
@@ -1106,26 +1219,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
@@ -1180,7 +1287,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
@@ -1190,14 +1297,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";
@@ -1209,47 +1310,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;
@@ -1258,14 +1377,19 @@ var RemoteData;
 // 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));
@@ -1278,10 +1402,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;
         }
@@ -1334,16 +1460,13 @@ var TaskMaybe;
   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);
@@ -1357,36 +1480,29 @@ var TaskMaybe;
 var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.error(error));
-  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.error(onNull()) : Result.ok(value));
-  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.error(onNone()) : Result.ok(maybe.value));
+  TaskResult2.err = (error) => Task.resolve(Result.err(error));
+  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
+  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
   TaskResult2.fromResult = (result) => Task.resolve(result);
-  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(
-    () => f(...args).then(Result.ok).catch((e) => Result.error(onError(e)))
-  );
-  TaskResult2.tryCatch = (f, onError) => Task.from(
-    (signal) => f(signal).then(Result.ok).catch((e) => Result.error(onError(e)))
-  );
+  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 = {}));
@@ -1394,102 +1510,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.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.invalid)(onNull()) : (0, Validation2.valid)(value);
-  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.invalid)(onNone()) : (0, Validation2.valid)(maybe.value);
-  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.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.invalid(onNull()) : Validation.valid(value));
-  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.invalid(onNone()) : Validation.valid(maybe.value));
+  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.valid).catch((e) => Validation.invalid(onError(e)))
-  );
+  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 = {}));
 
@@ -1498,58 +1609,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 = {}));