@nlozgachev/pipelined 0.32.0 → 0.34.0

package/dist/utils.js

@@ -43,35 +43,48 @@ var Deferred;
 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
@@ -86,7 +99,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;
@@ -94,7 +107,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;
@@ -102,8 +117,34 @@ var Maybe;
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
 })(Maybe || (Maybe = {}));
 
+// src/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/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs = (duration) => Duration.toMilliseconds(duration);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
@@ -111,12 +152,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);
@@ -126,35 +162,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));
+      }, getMs(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);
@@ -167,7 +207,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, delayDuration ? getMs(delayDuration) : 0);
       });
     };
     const run2 = (left) => {
@@ -176,18 +216,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);
@@ -200,7 +244,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, delayDuration ? getMs(delayDuration) : 0);
       });
     };
     const run2 = (attempt, lastValue) => {
@@ -208,15 +252,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) {
@@ -227,19 +311,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();
@@ -252,12 +336,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()));
+        }, getMs(duration));
       })
     ]);
   });
@@ -294,35 +378,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;
   };
@@ -330,7 +422,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;
   };
@@ -342,18 +436,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 = [];
@@ -377,12 +505,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) => {
@@ -402,7 +534,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]);
@@ -410,7 +544,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));
@@ -440,7 +576,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;
   };
@@ -450,7 +588,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);
@@ -460,7 +600,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);
@@ -473,7 +615,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);
@@ -483,27 +627,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;
@@ -513,14 +671,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) => {
@@ -551,8 +713,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;
   };
@@ -569,7 +734,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;
@@ -596,21 +763,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;
   };
@@ -618,7 +791,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;
   };
@@ -632,14 +807,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;
   };
@@ -664,7 +843,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++) {
@@ -675,7 +856,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);
   };
@@ -691,23 +874,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);
   };
@@ -719,16 +912,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]),
@@ -740,10 +950,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;
@@ -873,6 +1085,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
@@ -886,20 +1105,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;
@@ -914,29 +1141,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) => {