@nlozgachev/pipelined 0.32.0 → 0.34.0

package/dist/index.js

@@ -25,6 +25,7 @@ __export(src_exports, {
   Combinable: () => Combinable,
   Deferred: () => Deferred,
   Dict: () => Dict,
+  Duration: () => Duration,
   Equality: () => Equality,
   Lazy: () => Lazy,
   Lens: () => Lens,
@@ -86,44 +87,54 @@ module.exports = __toCommonJS(src_exports);
 function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
   const len = arguments.length;
   switch (len) {
-    case 1:
+    case 1: {
       return f0;
-    case 2:
+    }
+    case 2: {
       return function() {
         return f0(f1.apply(this, arguments));
       };
-    case 3:
+    }
+    case 3: {
       return function() {
         return f0(f1(f2.apply(this, arguments)));
       };
-    case 4:
+    }
+    case 4: {
       return function() {
         return f0(f1(f2(f3.apply(this, arguments))));
       };
-    case 5:
+    }
+    case 5: {
       return function() {
         return f0(f1(f2(f3(f4.apply(this, arguments)))));
       };
-    case 6:
+    }
+    case 6: {
       return function() {
         return f0(f1(f2(f3(f4(f5.apply(this, arguments))))));
       };
-    case 7:
+    }
+    case 7: {
       return function() {
         return f0(f1(f2(f3(f4(f5(f6.apply(this, arguments)))))));
       };
-    case 8:
+    }
+    case 8: {
       return function() {
         return f0(f1(f2(f3(f4(f5(f6(f7.apply(this, arguments))))))));
       };
-    case 9:
+    }
+    case 9: {
       return function() {
         return f0(f1(f2(f3(f4(f5(f6(f7(f8.apply(this, arguments)))))))));
       };
-    case 10:
+    }
+    case 10: {
       return function() {
         return f0(f1(f2(f3(f4(f5(f6(f7(f8(f9.apply(this, arguments))))))))));
       };
+    }
   }
 }
 
@@ -144,48 +155,59 @@ var flip = (f) => (b) => (a) => f(a)(b);
 function flow(ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
   const len = arguments.length;
   switch (len) {
-    case 0:
+    case 0: {
       return function(...args) {
         return args[0];
       };
-    case 1:
+    }
+    case 1: {
       return ab;
-    case 2:
+    }
+    case 2: {
       return function() {
         return bc(ab.apply(this, arguments));
       };
-    case 3:
+    }
+    case 3: {
       return function() {
         return cd(bc(ab.apply(this, arguments)));
       };
-    case 4:
+    }
+    case 4: {
       return function() {
         return de(cd(bc(ab.apply(this, arguments))));
       };
-    case 5:
+    }
+    case 5: {
       return function() {
         return ef(de(cd(bc(ab.apply(this, arguments)))));
       };
-    case 6:
+    }
+    case 6: {
       return function() {
         return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
       };
-    case 7:
+    }
+    case 7: {
       return function() {
         return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
       };
-    case 8:
+    }
+    case 8: {
       return function() {
         return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
       };
-    case 9:
+    }
+    case 9: {
       return function() {
         return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
       };
-    case 10:
+    }
+    case 10: {
       return function() {
         return jk(ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))));
       };
+    }
   }
 }
 
@@ -251,28 +273,39 @@ var on = (f, g) => (a, b) => f(g(a), g(b));
 // src/Composition/pipe.ts
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
   switch (arguments.length) {
-    case 1:
+    case 1: {
       return a;
-    case 2:
+    }
+    case 2: {
       return ab(a);
-    case 3:
+    }
+    case 3: {
       return bc(ab(a));
-    case 4:
+    }
+    case 4: {
       return cd(bc(ab(a)));
-    case 5:
+    }
+    case 5: {
       return de(cd(bc(ab(a))));
-    case 6:
+    }
+    case 6: {
       return ef(de(cd(bc(ab(a)))));
-    case 7:
+    }
+    case 7: {
       return fg(ef(de(cd(bc(ab(a))))));
-    case 8:
+    }
+    case 8: {
       return gh(fg(ef(de(cd(bc(ab(a)))))));
-    case 9:
+    }
+    case 9: {
       return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    case 10:
+    }
+    case 10: {
       return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
-    case 11:
+    }
+    case 11: {
       return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
+    }
   }
 }
 
@@ -296,35 +329,48 @@ var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
 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
@@ -339,7 +385,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;
@@ -347,7 +393,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;
@@ -358,30 +406,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))
@@ -441,17 +471,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)
@@ -486,6 +510,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" };
@@ -494,11 +543,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();
@@ -507,23 +560,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);
@@ -532,7 +603,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) => {
@@ -543,7 +616,7 @@ var execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying)
       timerId = setTimeout(() => {
         controller.abort();
         resolve(err(timeoutOptions.onTimeout()));
-      }, timeoutOptions.ms);
+      }, getMs(timeoutOptions.duration));
     })
   ]));
 };
@@ -569,14 +642,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;
@@ -584,12 +663,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 {
@@ -604,7 +685,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 {
@@ -615,13 +698,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);
     }
   };
@@ -647,19 +732,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);
+            }
           }
         });
       })
@@ -674,7 +766,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 {
@@ -685,13 +779,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);
     }
   };
@@ -716,12 +812,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;
@@ -778,7 +878,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));
   };
@@ -790,13 +892,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);
     }
   };
@@ -818,10 +922,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;
@@ -854,7 +962,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));
   };
@@ -866,18 +976,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;
@@ -898,10 +1010,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;
@@ -914,7 +1030,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;
@@ -922,10 +1040,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;
@@ -934,11 +1056,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);
   };
@@ -981,7 +1105,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);
@@ -994,18 +1120,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;
@@ -1023,10 +1151,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;
@@ -1045,7 +1177,7 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
         fireOp(input, resolve);
         startCooldown();
       }
-    }, ms);
+    }, getMs(duration));
   };
   const run = (input) => {
     if (cooldownTimer !== void 0) {
@@ -1080,7 +1212,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);
   };
@@ -1092,13 +1226,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);
     }
   };
@@ -1122,12 +1258,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;
@@ -1167,7 +1307,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));
   };
@@ -1179,13 +1321,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);
     }
   };
@@ -1216,7 +1360,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);
@@ -1249,7 +1393,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));
     }
   };
@@ -1261,7 +1407,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: () => {
@@ -1270,7 +1418,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);
     }
   };
@@ -1295,10 +1443,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;
@@ -1313,7 +1465,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 {
@@ -1324,13 +1478,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);
     }
   };
@@ -1342,62 +1498,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,
@@ -1407,13 +1581,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,
@@ -1421,8 +1606,10 @@ var Op;
           retryOptions,
           timeoutOptions
         );
-      case "keyed":
+      }
+      case "keyed": {
         return makeKeyed(op, options.key ?? ((i) => i), options.perKey ?? "exclusive", timeoutOptions);
+      }
     }
   }
   Op2.interpret = interpret;
@@ -1432,22 +1619,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) => {
@@ -1466,26 +1649,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
@@ -1540,7 +1717,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
@@ -1550,14 +1727,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";
@@ -1569,47 +1740,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;
@@ -1617,6 +1806,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));
@@ -1624,12 +1814,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);
@@ -1639,35 +1824,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);
@@ -1680,7 +1869,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, delayDuration ? getMs2(delayDuration) : 0);
       });
     };
     const run2 = (left) => {
@@ -1689,18 +1878,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);
@@ -1713,7 +1906,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, delayDuration ? getMs2(delayDuration) : 0);
       });
     };
     const run2 = (attempt, lastValue) => {
@@ -1721,15 +1914,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) {
@@ -1740,19 +1973,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();
@@ -1765,12 +1998,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));
       })
     ]);
   });
@@ -1798,14 +2031,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));
@@ -1818,10 +2056,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;
         }
@@ -1871,17 +2111,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);
@@ -1895,30 +2134,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 = {}));
@@ -1926,97 +2164,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 = {}));
 
@@ -2025,58 +2263,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 = {}));
@@ -2102,13 +2366,6 @@ var Tuple;
   };
 })(Tuple || (Tuple = {}));
 
-// src/Types/Brand.ts
-var Brand;
-((Brand2) => {
-  Brand2.wrap = () => (value) => value;
-  Brand2.unwrap = (branded) => branded;
-})(Brand || (Brand = {}));
-
 // src/Types/NonEmptyList.ts
 var isNonEmptyList = (list) => list.length > 0;
 
@@ -2121,35 +2378,43 @@ var Arr;
   Arr2.init = (data) => data.length > 0 ? Maybe.some(data.slice(0, -1)) : Maybe.none();
   Arr2.findFirst = (predicate) => (data) => {
     const idx = data.findIndex(predicate);
-    return idx >= 0 ? Maybe.some(data[idx]) : Maybe.none();
+    return idx !== -1 ? Maybe.some(data[idx]) : Maybe.none();
   };
   Arr2.findLast = (predicate) => (data) => {
     for (let i = data.length - 1; i >= 0; i--) {
-      if (predicate(data[i])) return Maybe.some(data[i]);
+      if (predicate(data[i])) {
+        return Maybe.some(data[i]);
+      }
     }
     return Maybe.none();
   };
   Arr2.findIndex = (predicate) => (data) => {
     const idx = data.findIndex(predicate);
-    return idx >= 0 ? Maybe.some(idx) : Maybe.none();
+    return idx !== -1 ? Maybe.some(idx) : Maybe.none();
   };
   Arr2.map = (f) => (data) => {
     const n = data.length;
     const result = new Array(n);
-    for (let i = 0; i < n; i++) result[i] = f(data[i]);
+    for (let i = 0; i < n; i++) {
+      result[i] = f(data[i]);
+    }
     return result;
   };
   Arr2.mapWithIndex = (f) => (data) => {
     const n = data.length;
     const result = new Array(n);
-    for (let i = 0; i < n; i++) result[i] = f(i, data[i]);
+    for (let i = 0; i < n; i++) {
+      result[i] = f(i, data[i]);
+    }
     return result;
   };
   Arr2.filter = (predicate) => (data) => {
     const n = data.length;
     const result = [];
     for (let i = 0; i < n; i++) {
-      if (predicate(data[i])) result.push(data[i]);
+      if (predicate(data[i])) {
+        result.push(data[i]);
+      }
     }
     return result;
   };
@@ -2157,7 +2422,9 @@ var Arr;
     const result = [];
     for (let i = 0; i < data.length; i++) {
       const mapped = f(data[i]);
-      if (mapped.kind === "Some") result.push(mapped.value);
+      if (mapped.kind === "Some") {
+        result.push(mapped.value);
+      }
     }
     return result;
   };
@@ -2169,18 +2436,52 @@ var Arr;
     }
     return [pass, fail];
   };
+  Arr2.compact = (data) => {
+    const result = [];
+    for (const item of data) {
+      if (item.kind === "Some") {
+        result.push(item.value);
+      }
+    }
+    return result;
+  };
+  Arr2.separate = (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      if (item.kind === "Ok") {
+        successes.push(item.value);
+      } else {
+        errors.push(item.error);
+      }
+    }
+    return [errors, successes];
+  };
+  Arr2.partitionMap = (f) => (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      const mapped = f(item);
+      if (mapped.kind === "Ok") {
+        successes.push(mapped.value);
+      } else {
+        errors.push(mapped.error);
+      }
+    }
+    return [errors, successes];
+  };
   Arr2.groupBy = (f) => (data) => {
     const result = {};
     for (const a of data) {
       const key = f(a);
-      if (!result[key]) result[key] = [];
+      if (!result[key]) {
+        result[key] = [];
+      }
       result[key].push(a);
     }
     return result;
   };
-  Arr2.uniq = (data) => [
-    ...new Set(data)
-  ];
+  Arr2.uniq = (data) => [...new Set(data)];
   Arr2.uniqBy = (f) => (data) => {
     const seen = /* @__PURE__ */ new Set();
     const result = [];
@@ -2204,12 +2505,16 @@ var Arr;
   };
   Arr2.sortBy = (compare) => (data) => {
     const arr = data;
-    if (typeof arr.toSorted === "function") return arr.toSorted(compare);
-    return [...data].sort(compare);
+    if (typeof arr.toSorted === "function") {
+      return arr.toSorted(compare);
+    }
+    return [...data].toSorted(compare);
   };
   Arr2.sortWith = (ord) => (data) => {
     const arr = data;
-    if (typeof arr.toSorted === "function") return arr.toSorted(ord);
+    if (typeof arr.toSorted === "function") {
+      return arr.toSorted(ord);
+    }
     return [...data].sort(ord);
   };
   Arr2.zip = (other) => (data) => {
@@ -2229,7 +2534,9 @@ var Arr;
     return result;
   };
   Arr2.intersperse = (sep) => (data) => {
-    if (data.length <= 1) return data;
+    if (data.length <= 1) {
+      return data;
+    }
     const result = [data[0]];
     for (let i = 1; i < data.length; i++) {
       result.push(sep, data[i]);
@@ -2237,7 +2544,9 @@ var Arr;
     return result;
   };
   Arr2.chunksOf = (n) => (data) => {
-    if (n <= 0) return [];
+    if (n <= 0) {
+      return [];
+    }
     const result = [];
     for (let i = 0; i < data.length; i += n) {
       result.push(data.slice(i, i + n));
@@ -2267,7 +2576,9 @@ var Arr;
     for (let i = 0; i < n; i++) {
       const chunk = f(data[i]);
       const m = chunk.length;
-      for (let j = 0; j < m; j++) result.push(chunk[j]);
+      for (let j = 0; j < m; j++) {
+        result.push(chunk[j]);
+      }
     }
     return result;
   };
@@ -2277,7 +2588,9 @@ var Arr;
     const result = new Array(n);
     for (let i = 0; i < n; i++) {
       const mapped = f(data[i]);
-      if (mapped.kind === "None") return Maybe.none();
+      if (mapped.kind === "None") {
+        return Maybe.none();
+      }
       result[i] = mapped.value;
     }
     return Maybe.some(result);
@@ -2287,7 +2600,9 @@ var Arr;
     const result = new Array(n);
     for (let i = 0; i < n; i++) {
       const mapped = f(data[i]);
-      if (mapped.kind === "Error") return mapped;
+      if (mapped.kind === "Err") {
+        return mapped;
+      }
       result[i] = mapped.value;
     }
     return Result.ok(result);
@@ -2300,7 +2615,9 @@ var Arr;
     const result = [];
     for (const a of data) {
       const r = await Deferred.toPromise(f(a)());
-      if (Result.isError(r)) return r;
+      if (Result.isErr(r)) {
+        return r;
+      }
       result.push(r.value);
     }
     return Result.ok(result);
@@ -2310,27 +2627,41 @@ var Arr;
   Arr2.size = (data) => data.length;
   Arr2.some = (predicate) => (data) => {
     const n = data.length;
-    for (let i = 0; i < n; i++) if (predicate(data[i])) return true;
+    for (let i = 0; i < n; i++) {
+      if (predicate(data[i])) {
+        return true;
+      }
+    }
     return false;
   };
   Arr2.every = (predicate) => (data) => {
     const n = data.length;
-    for (let i = 0; i < n; i++) if (!predicate(data[i])) return false;
+    for (let i = 0; i < n; i++) {
+      if (!predicate(data[i])) {
+        return false;
+      }
+    }
     return true;
   };
-  Arr2.reverse = (data) => [...data].reverse();
+  Arr2.reverse = (data) => [...data].toReversed();
   Arr2.insertAt = (index, item) => (data) => {
     const i = Math.max(0, Math.min(index, data.length));
     const arr = data;
-    if (typeof arr.toSpliced === "function") return arr.toSpliced(i, 0, item);
+    if (typeof arr.toSpliced === "function") {
+      return arr.toSpliced(i, 0, item);
+    }
     const result = [...data];
     result.splice(i, 0, item);
     return result;
   };
   Arr2.removeAt = (index) => (data) => {
-    if (index < 0 || index >= data.length) return data;
+    if (index < 0 || index >= data.length) {
+      return data;
+    }
     const arr = data;
-    if (typeof arr.toSpliced === "function") return arr.toSpliced(index, 1);
+    if (typeof arr.toSpliced === "function") {
+      return arr.toSpliced(index, 1);
+    }
     const result = [...data];
     result.splice(index, 1);
     return result;
@@ -2340,14 +2671,18 @@ var Arr;
   Arr2.takeWhile = (predicate) => (data) => {
     const result = [];
     for (const a of data) {
-      if (!predicate(a)) break;
+      if (!predicate(a)) {
+        break;
+      }
       result.push(a);
     }
     return result;
   };
   Arr2.dropWhile = (predicate) => (data) => {
     let i = 0;
-    while (i < data.length && predicate(data[i])) i++;
+    while (i < data.length && predicate(data[i])) {
+      i++;
+    }
     return data.slice(i);
   };
   Arr2.scan = (initial, f) => (data) => {
@@ -2378,8 +2713,11 @@ var Dict;
     for (const item of items) {
       const key = keyFn(item);
       const arr = result.get(key);
-      if (arr !== void 0) arr.push(item);
-      else result.set(key, [item]);
+      if (arr !== void 0) {
+        arr.push(item);
+      } else {
+        result.set(key, [item]);
+      }
     }
     return result;
   };
@@ -2396,7 +2734,9 @@ var Dict;
     return result;
   };
   Dict2.remove = (key) => (m) => {
-    if (!m.has(key)) return m;
+    if (!m.has(key)) {
+      return m;
+    }
     const result = new globalThis.Map(m);
     result.delete(key);
     return result;
@@ -2423,21 +2763,27 @@ var Dict;
   Dict2.filter = (predicate) => (m) => {
     const result = new globalThis.Map();
     for (const [k, v] of m) {
-      if (predicate(v)) result.set(k, v);
+      if (predicate(v)) {
+        result.set(k, v);
+      }
     }
     return result;
   };
   Dict2.filterWithKey = (predicate) => (m) => {
     const result = new globalThis.Map();
     for (const [k, v] of m) {
-      if (predicate(k, v)) result.set(k, v);
+      if (predicate(k, v)) {
+        result.set(k, v);
+      }
     }
     return result;
   };
   Dict2.compact = (m) => {
     const result = new globalThis.Map();
     for (const [k, v] of m) {
-      if (v.kind === "Some") result.set(k, v.value);
+      if (v.kind === "Some") {
+        result.set(k, v.value);
+      }
     }
     return result;
   };
@@ -2445,7 +2791,9 @@ var Dict;
     const result = new globalThis.Map();
     for (const [key, value] of m) {
       const mapped = f(value);
-      if (mapped.kind === "Some") result.set(key, mapped.value);
+      if (mapped.kind === "Some") {
+        result.set(key, mapped.value);
+      }
     }
     return result;
   };
@@ -2459,14 +2807,18 @@ var Dict;
   Dict2.intersection = (other) => (m) => {
     const result = new globalThis.Map();
     for (const [k, v] of m) {
-      if (other.has(k)) result.set(k, v);
+      if (other.has(k)) {
+        result.set(k, v);
+      }
     }
     return result;
   };
   Dict2.difference = (other) => (m) => {
     const result = new globalThis.Map();
     for (const [k, v] of m) {
-      if (!other.has(k)) result.set(k, v);
+      if (!other.has(k)) {
+        result.set(k, v);
+      }
     }
     return result;
   };
@@ -2491,7 +2843,9 @@ var Dict;
 var Num;
 ((Num2) => {
   Num2.range = (from, to, step = 1) => {
-    if (step <= 0 || from > to) return [];
+    if (step <= 0 || from > to) {
+      return [];
+    }
     const count = Math.floor((to - from) / step) + 1;
     const result = new Array(count);
     for (let i = 0; i < count; i++) {
@@ -2502,7 +2856,9 @@ var Num;
   Num2.clamp = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
   Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
   Num2.parse = (s) => {
-    if (s.trim() === "") return Maybe.none();
+    if (s.trim() === "") {
+      return Maybe.none();
+    }
     const n = Number(s);
     return isNaN(n) ? Maybe.none() : Maybe.some(n);
   };
@@ -2518,23 +2874,33 @@ var Num;
   Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.none() : Maybe.some(n % divisor);
   Num2.sum = (ns) => {
     let result = 0;
-    for (let i = 0; i < ns.length; i++) result += ns[i];
+    for (let i = 0; i < ns.length; i++) {
+      result += ns[i];
+    }
     return result;
   };
   Num2.mean = (ns) => ns.length === 0 ? Maybe.none() : Maybe.some((0, Num2.sum)(ns) / ns.length);
   Num2.min = (ns) => {
-    if (ns.length === 0) return Maybe.none();
+    if (ns.length === 0) {
+      return Maybe.none();
+    }
     let [result] = ns;
     for (let i = 1; i < ns.length; i++) {
-      if (ns[i] < result) result = ns[i];
+      if (ns[i] < result) {
+        result = ns[i];
+      }
     }
     return Maybe.some(result);
   };
   Num2.max = (ns) => {
-    if (ns.length === 0) return Maybe.none();
+    if (ns.length === 0) {
+      return Maybe.none();
+    }
     let [result] = ns;
     for (let i = 1; i < ns.length; i++) {
-      if (ns[i] > result) result = ns[i];
+      if (ns[i] > result) {
+        result = ns[i];
+      }
     }
     return Maybe.some(result);
   };
@@ -2546,16 +2912,33 @@ var Rec;
   Rec2.map = (f) => (data) => {
     const keys2 = Object.keys(data);
     const vals = Object.values(data);
-    const result = {};
+    const result = Object.create(Object.getPrototypeOf(data));
     for (let i = 0; i < keys2.length; i++) {
       Object.defineProperty(result, keys2[i], { value: f(vals[i]), writable: true, enumerable: true, configurable: true });
     }
     return result;
   };
+  Rec2.filterMap = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    const vals = Object.values(data);
+    const result = Object.create(Object.getPrototypeOf(data));
+    for (let i = 0; i < keys2.length; i++) {
+      const maybeVal = f(vals[i]);
+      if (maybeVal.kind === "Some") {
+        Object.defineProperty(result, keys2[i], {
+          value: maybeVal.value,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return result;
+  };
   Rec2.mapWithKey = (f) => (data) => {
     const keys2 = Object.keys(data);
     const vals = Object.values(data);
-    const result = {};
+    const result = Object.create(Object.getPrototypeOf(data));
     for (let i = 0; i < keys2.length; i++) {
       Object.defineProperty(result, keys2[i], {
         value: f(keys2[i], vals[i]),
@@ -2567,10 +2950,12 @@ var Rec;
     return result;
   };
   Rec2.filter = (predicate) => (data) => {
-    const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      if (predicate(v)) {
-        Object.defineProperty(result, k, { value: v, writable: true, enumerable: true, configurable: true });
+    const keys2 = Object.keys(data);
+    const vals = Object.values(data);
+    const result = Object.create(Object.getPrototypeOf(data));
+    for (let i = 0; i < keys2.length; i++) {
+      if (predicate(vals[i])) {
+        Object.defineProperty(result, keys2[i], { value: vals[i], writable: true, enumerable: true, configurable: true });
       }
     }
     return result;
@@ -2700,6 +3085,13 @@ var Str;
       return isNaN(n) ? Maybe.none() : Maybe.some(n);
     }
   };
+  Str2.parseJson = (s) => {
+    try {
+      return Result.ok(JSON.parse(s));
+    } catch (error) {
+      return Result.err(error);
+    }
+  };
 })(Str || (Str = {}));
 
 // src/Utils/Uniq.ts
@@ -2713,20 +3105,28 @@ var Uniq;
   Uniq2.isEmpty = (s) => s.size === 0;
   Uniq2.isSubsetOf = (other) => (s) => {
     const set = s;
-    if (typeof set.isSubsetOf === "function") return set.isSubsetOf(other);
+    if (typeof set.isSubsetOf === "function") {
+      return set.isSubsetOf(other);
+    }
     for (const item of s) {
-      if (!other.has(item)) return false;
+      if (!other.has(item)) {
+        return false;
+      }
     }
     return true;
   };
   Uniq2.insert = (item) => (s) => {
-    if (s.has(item)) return s;
+    if (s.has(item)) {
+      return s;
+    }
     const result = new globalThis.Set(s);
     result.add(item);
     return result;
   };
   Uniq2.remove = (item) => (s) => {
-    if (!s.has(item)) return s;
+    if (!s.has(item)) {
+      return s;
+    }
     const result = new globalThis.Set(s);
     result.delete(item);
     return result;
@@ -2741,29 +3141,47 @@ var Uniq;
   Uniq2.filter = (predicate) => (s) => {
     const result = new globalThis.Set();
     for (const item of s) {
-      if (predicate(item)) result.add(item);
+      if (predicate(item)) {
+        result.add(item);
+      }
     }
     return result;
   };
   Uniq2.union = (other) => (s) => {
     const set = s;
-    if (typeof set.union === "function") return set.union(other);
+    if (typeof set.union === "function") {
+      return set.union(other);
+    }
     const result = new globalThis.Set(s);
-    for (const item of other) result.add(item);
+    for (const item of other) {
+      result.add(item);
+    }
     return result;
   };
   Uniq2.intersection = (other) => (s) => {
     const set = s;
-    if (typeof set.intersection === "function") return set.intersection(other);
+    if (typeof set.intersection === "function") {
+      return set.intersection(other);
+    }
     const result = new globalThis.Set();
-    for (const item of s) if (other.has(item)) result.add(item);
+    for (const item of s) {
+      if (other.has(item)) {
+        result.add(item);
+      }
+    }
     return result;
   };
   Uniq2.difference = (other) => (s) => {
     const set = s;
-    if (typeof set.difference === "function") return set.difference(other);
+    if (typeof set.difference === "function") {
+      return set.difference(other);
+    }
     const result = new globalThis.Set();
-    for (const item of s) if (!other.has(item)) result.add(item);
+    for (const item of s) {
+      if (!other.has(item)) {
+        result.add(item);
+      }
+    }
     return result;
   };
   Uniq2.reduce = (init, f) => (s) => {
@@ -2782,6 +3200,7 @@ var Uniq;
   Combinable,
   Deferred,
   Dict,
+  Duration,
   Equality,
   Lazy,
   Lens,