@nlozgachev/pipelined 0.12.0 → 0.14.0

package/dist/index.js

@@ -0,0 +1,1421 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Arr: () => Arr,
+  Brand: () => Brand,
+  Deferred: () => Deferred,
+  Dict: () => Dict,
+  Lens: () => Lens,
+  Logged: () => Logged,
+  Num: () => Num,
+  Option: () => Option,
+  Optional: () => Optional,
+  Predicate: () => Predicate,
+  Reader: () => Reader,
+  Rec: () => Rec,
+  Refinement: () => Refinement,
+  RemoteData: () => RemoteData,
+  Result: () => Result,
+  State: () => State,
+  Str: () => Str,
+  Task: () => Task,
+  TaskOption: () => TaskOption,
+  TaskResult: () => TaskResult,
+  TaskValidation: () => TaskValidation,
+  These: () => These,
+  Tuple: () => Tuple,
+  Uniq: () => Uniq,
+  Validation: () => Validation,
+  and: () => and,
+  compose: () => compose,
+  constFalse: () => constFalse,
+  constNull: () => constNull,
+  constTrue: () => constTrue,
+  constUndefined: () => constUndefined,
+  constVoid: () => constVoid,
+  constant: () => constant,
+  converge: () => converge,
+  curry: () => curry,
+  curry3: () => curry3,
+  curry4: () => curry4,
+  flip: () => flip,
+  flow: () => flow,
+  identity: () => identity,
+  isNonEmptyList: () => isNonEmptyList,
+  juxt: () => juxt,
+  memoize: () => memoize,
+  memoizeWeak: () => memoizeWeak,
+  not: () => not,
+  on: () => on,
+  once: () => once,
+  or: () => or,
+  pipe: () => pipe,
+  tap: () => tap,
+  uncurry: () => uncurry,
+  uncurry3: () => uncurry3,
+  uncurry4: () => uncurry4
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Composition/compose.ts
+function compose(...fns) {
+  return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
+}
+
+// src/Composition/converge.ts
+function converge(f, transformers) {
+  return (a) => f(...transformers.map((t) => t(a)));
+}
+
+// src/Composition/curry.ts
+var curry = (f) => (a) => (b) => f(a, b);
+var curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
+var curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);
+
+// src/Composition/flip.ts
+var flip = (f) => (b) => (a) => f(a)(b);
+
+// src/Composition/flow.ts
+function flow(...fns) {
+  return (...args) => {
+    if (fns.length === 0) return args[0];
+    const [first, ...rest] = fns;
+    return rest.reduce((acc, fn) => fn(acc), first(...args));
+  };
+}
+
+// src/Composition/fn.ts
+var identity = (a) => a;
+var constant = (a) => () => a;
+var constTrue = () => true;
+var constFalse = () => false;
+var constNull = () => null;
+var constUndefined = () => void 0;
+var constVoid = () => {
+};
+var and = (p1, p2) => (...args) => p1(...args) && p2(...args);
+var or = (p1, p2) => (...args) => p1(...args) || p2(...args);
+var once = (f) => {
+  let called = false;
+  let result;
+  return () => {
+    if (!called) {
+      result = f();
+      called = true;
+    }
+    return result;
+  };
+};
+
+// src/Composition/juxt.ts
+function juxt(fns) {
+  return (a) => fns.map((f) => f(a));
+}
+
+// src/Composition/memoize.ts
+var memoize = (f, keyFn = (a) => a) => {
+  const cache = /* @__PURE__ */ new Map();
+  return (a) => {
+    const key = keyFn(a);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = f(a);
+    cache.set(key, result);
+    return result;
+  };
+};
+var memoizeWeak = (f) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (a) => {
+    if (cache.has(a)) {
+      return cache.get(a);
+    }
+    const result = f(a);
+    cache.set(a, result);
+    return result;
+  };
+};
+
+// src/Composition/not.ts
+var not = (predicate) => (...args) => !predicate(...args);
+
+// src/Composition/on.ts
+var on = (f, g) => (a, b) => f(g(a), g(b));
+
+// src/Composition/pipe.ts
+function pipe(a, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), a);
+}
+
+// src/Composition/tap.ts
+var tap = (f) => (a) => {
+  f(a);
+  return a;
+};
+
+// src/Composition/uncurry.ts
+function uncurry(f) {
+  return (...args) => {
+    const inner = f(...args.slice(0, f.length));
+    return inner.length === 0 ? inner() : inner(...args.slice(f.length));
+  };
+}
+var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
+var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
+
+// src/Core/Deferred.ts
+var _store = /* @__PURE__ */ new WeakMap();
+var Deferred;
+((Deferred2) => {
+  Deferred2.fromPromise = (p) => {
+    const d = { then: ((f) => p.then(f)) };
+    _store.set(d, p);
+    return d;
+  };
+  Deferred2.toPromise = (d) => _store.get(d) ?? new Promise((resolve) => d.then(resolve));
+})(Deferred || (Deferred = {}));
+
+// src/Core/Lens.ts
+var Lens;
+((Lens2) => {
+  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
+  Lens2.prop = () => (key) => (0, Lens2.make)(
+    (s) => s[key],
+    (a) => (s) => ({ ...s, [key]: a })
+  );
+  Lens2.get = (lens) => (s) => lens.get(s);
+  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
+  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
+  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)(
+    (s) => inner.get(outer.get(s)),
+    (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  );
+  Lens2.andThenOptional = (inner) => (outer) => ({
+    get: (s) => inner.get(outer.get(s)),
+    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  });
+  Lens2.toOptional = (lens) => ({
+    get: (s) => ({ kind: "Some", value: lens.get(s) }),
+    set: lens.set
+  });
+})(Lens || (Lens = {}));
+
+// src/Core/Logged.ts
+var Logged;
+((Logged2) => {
+  Logged2.make = (value) => ({ value, log: [] });
+  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
+  Logged2.map = (f) => (data) => ({
+    value: f(data.value),
+    log: data.log
+  });
+  Logged2.chain = (f) => (data) => {
+    const next = f(data.value);
+    return { value: next.value, log: [...data.log, ...next.log] };
+  };
+  Logged2.ap = (arg) => (data) => ({
+    value: data.value(arg.value),
+    log: [...data.log, ...arg.log]
+  });
+  Logged2.tap = (f) => (data) => {
+    f(data.value);
+    return data;
+  };
+  Logged2.run = (data) => [data.value, data.log];
+})(Logged || (Logged = {}));
+
+// src/Core/Result.ts
+var Result;
+((Result2) => {
+  Result2.ok = (value) => ({ kind: "Ok", value });
+  Result2.err = (error) => ({ kind: "Error", error });
+  Result2.isOk = (data) => data.kind === "Ok";
+  Result2.isErr = (data) => data.kind === "Error";
+  Result2.tryCatch = (f, onError) => {
+    try {
+      return (0, Result2.ok)(f());
+    } catch (e) {
+      return (0, Result2.err)(onError(e));
+    }
+  };
+  Result2.map = (f) => (data) => (0, Result2.isOk)(data) ? (0, Result2.ok)(f(data.value)) : 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);
+    return data;
+  };
+  Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
+  Result2.recoverUnless = (blockedErr, fallback) => (data) => (0, Result2.isErr)(data) && data.error !== blockedErr ? fallback() : data;
+  Result2.toOption = (data) => (0, Result2.isOk)(data) ? Option.some(data.value) : Option.none();
+  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/Option.ts
+var _none = { kind: "None" };
+var Option;
+((Option2) => {
+  Option2.some = (value) => ({ kind: "Some", value });
+  Option2.isSome = (data) => data.kind === "Some";
+  Option2.none = () => _none;
+  Option2.isNone = (data) => data.kind === "None";
+  Option2.fromNullable = (value) => value === null || value === void 0 ? (0, Option2.none)() : (0, Option2.some)(value);
+  Option2.toNullable = (data) => (0, Option2.isSome)(data) ? data.value : null;
+  Option2.toUndefined = (data) => (0, Option2.isSome)(data) ? data.value : void 0;
+  Option2.fromUndefined = (value) => value === void 0 ? (0, Option2.none)() : (0, Option2.some)(value);
+  Option2.toResult = (onNone) => (data) => (0, Option2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
+  Option2.fromResult = (data) => Result.isOk(data) ? (0, Option2.some)(data.value) : (0, Option2.none)();
+  Option2.map = (f) => (data) => (0, Option2.isSome)(data) ? (0, Option2.some)(f(data.value)) : data;
+  Option2.chain = (f) => (data) => (0, Option2.isSome)(data) ? f(data.value) : data;
+  Option2.fold = (onNone, onSome) => (data) => (0, Option2.isSome)(data) ? onSome(data.value) : onNone();
+  Option2.match = (cases) => (data) => (0, Option2.isSome)(data) ? cases.some(data.value) : cases.none();
+  Option2.getOrElse = (defaultValue) => (data) => (0, Option2.isSome)(data) ? data.value : defaultValue();
+  Option2.tap = (f) => (data) => {
+    if ((0, Option2.isSome)(data)) f(data.value);
+    return data;
+  };
+  Option2.filter = (predicate) => (data) => (0, Option2.isSome)(data) ? predicate(data.value) ? data : (0, Option2.none)() : data;
+  Option2.recover = (fallback) => (data) => (0, Option2.isSome)(data) ? data : fallback();
+  Option2.ap = (arg) => (data) => (0, Option2.isSome)(data) && (0, Option2.isSome)(arg) ? (0, Option2.some)(data.value(arg.value)) : (0, Option2.none)();
+})(Option || (Option = {}));
+
+// src/Core/Optional.ts
+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 ? Option.some(val) : Option.none();
+    },
+    (a) => (s) => ({ ...s, [key]: a })
+  );
+  Optional2.index = (i) => (0, Optional2.make)(
+    (arr) => i >= 0 && i < arr.length ? Option.some(arr[i]) : Option.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) => {
+    const val = opt.get(s);
+    return val.kind === "None" ? s : opt.set(f(val.value))(s);
+  };
+  Optional2.getOrElse = (opt) => (defaultValue) => (s) => {
+    const val = opt.get(s);
+    return val.kind === "Some" ? val.value : defaultValue();
+  };
+  Optional2.fold = (opt) => (onNone, onSome) => (s) => {
+    const val = opt.get(s);
+    return val.kind === "Some" ? onSome(val.value) : onNone();
+  };
+  Optional2.match = (opt) => (cases) => (s) => {
+    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" ? Option.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" ? Option.none() : Option.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/Predicate.ts
+var Predicate;
+((Predicate2) => {
+  Predicate2.not = (p) => (a) => !p(a);
+  Predicate2.and = (second) => (first) => (a) => first(a) && second(a);
+  Predicate2.or = (second) => (first) => (a) => first(a) || second(a);
+  Predicate2.using = (f) => (p) => (b) => p(f(b));
+  Predicate2.all = (predicates) => (a) => predicates.every((p) => p(a));
+  Predicate2.any = (predicates) => (a) => predicates.some((p) => p(a));
+  Predicate2.fromRefinement = (r) => r;
+})(Predicate || (Predicate = {}));
+
+// src/Core/Reader.ts
+var Reader;
+((Reader2) => {
+  Reader2.resolve = (value) => (_env) => value;
+  Reader2.ask = () => (env) => env;
+  Reader2.asks = (f) => (env) => f(env);
+  Reader2.map = (f) => (data) => (env) => f(data(env));
+  Reader2.chain = (f) => (data) => (env) => f(data(env))(env);
+  Reader2.ap = (arg) => (data) => (env) => data(env)(arg(env));
+  Reader2.tap = (f) => (data) => (env) => {
+    const a = data(env);
+    f(a);
+    return a;
+  };
+  Reader2.local = (f) => (data) => (env) => data(f(env));
+  Reader2.run = (env) => (data) => data(env);
+})(Reader || (Reader = {}));
+
+// src/Core/Refinement.ts
+var Refinement;
+((Refinement2) => {
+  Refinement2.make = (f) => f;
+  Refinement2.compose = (bc) => (ab) => (a) => ab(a) && bc(a);
+  Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
+  Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
+  Refinement2.toFilter = (r) => (a) => r(a) ? Option.some(a) : Option.none();
+  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
+})(Refinement || (Refinement = {}));
+
+// src/Core/RemoteData.ts
+var _notAsked = { kind: "NotAsked" };
+var _loading = { kind: "Loading" };
+var RemoteData;
+((RemoteData2) => {
+  RemoteData2.notAsked = () => _notAsked;
+  RemoteData2.loading = () => _loading;
+  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";
+  RemoteData2.isSuccess = (data) => data.kind === "Success";
+  RemoteData2.map = (f) => (data) => (0, RemoteData2.isSuccess)(data) ? (0, RemoteData2.success)(f(data.value)) : data;
+  RemoteData2.mapError = (f) => (data) => (0, RemoteData2.isFailure)(data) ? (0, RemoteData2.failure)(f(data.error)) : data;
+  RemoteData2.chain = (f) => (data) => (0, RemoteData2.isSuccess)(data) ? f(data.value) : data;
+  RemoteData2.ap = (arg) => (data) => {
+    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)();
+    return (0, RemoteData2.notAsked)();
+  };
+  RemoteData2.fold = (onNotAsked, onLoading, onFailure, onSuccess) => (data) => {
+    switch (data.kind) {
+      case "NotAsked":
+        return onNotAsked();
+      case "Loading":
+        return onLoading();
+      case "Failure":
+        return onFailure(data.error);
+      case "Success":
+        return onSuccess(data.value);
+    }
+  };
+  RemoteData2.match = (cases) => (data) => {
+    switch (data.kind) {
+      case "NotAsked":
+        return cases.notAsked();
+      case "Loading":
+        return cases.loading();
+      case "Failure":
+        return cases.failure(data.error);
+      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);
+    return data;
+  };
+  RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
+  RemoteData2.toOption = (data) => (0, RemoteData2.isSuccess)(data) ? Option.some(data.value) : Option.none();
+  RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
+})(RemoteData || (RemoteData = {}));
+
+// src/Core/State.ts
+var State;
+((State2) => {
+  State2.resolve = (value) => (s) => [value, s];
+  State2.get = () => (s) => [s, s];
+  State2.gets = (f) => (s) => [f(s), s];
+  State2.put = (newState) => (_s) => [void 0, newState];
+  State2.modify = (f) => (s) => [void 0, f(s)];
+  State2.map = (f) => (st) => (s) => {
+    const [a, s1] = st(s);
+    return [f(a), s1];
+  };
+  State2.chain = (f) => (st) => (s) => {
+    const [a, s1] = st(s);
+    return f(a)(s1);
+  };
+  State2.ap = (arg) => (fn) => (s) => {
+    const [f, s1] = fn(s);
+    const [a, s2] = arg(s1);
+    return [f(a), s2];
+  };
+  State2.tap = (f) => (st) => (s) => {
+    const [a, s1] = st(s);
+    f(a);
+    return [a, s1];
+  };
+  State2.run = (initialState) => (st) => st(initialState);
+  State2.evaluate = (initialState) => (st) => st(initialState)[0];
+  State2.execute = (initialState) => (st) => st(initialState)[1];
+})(State || (State = {}));
+
+// src/Core/Task.ts
+var toPromise = (task) => Deferred.toPromise(task());
+var Task;
+((Task2) => {
+  Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
+  Task2.from = (f) => () => Deferred.fromPromise(f());
+  Task2.map = (f) => (data) => (0, Task2.from)(() => toPromise(data).then(f));
+  Task2.chain = (f) => (data) => (0, Task2.from)(() => toPromise(data).then((a) => toPromise(f(a))));
+  Task2.ap = (arg) => (data) => (0, Task2.from)(
+    () => Promise.all([
+      toPromise(data),
+      toPromise(arg)
+    ]).then(([f, a]) => f(a))
+  );
+  Task2.tap = (f) => (data) => (0, Task2.from)(
+    () => toPromise(data).then((a) => {
+      f(a);
+      return a;
+    })
+  );
+  Task2.all = (tasks) => (0, Task2.from)(
+    () => Promise.all(tasks.map((t) => toPromise(t)))
+  );
+  Task2.delay = (ms) => (data) => (0, Task2.from)(
+    () => new Promise(
+      (resolve2) => setTimeout(
+        () => toPromise(data).then(resolve2),
+        ms
+      )
+    )
+  );
+  Task2.repeat = (options) => (task) => (0, Task2.from)(() => {
+    const { times, delay: ms } = options;
+    if (times <= 0) return Promise.resolve([]);
+    const results = [];
+    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+    const run = (left) => toPromise(task).then((a) => {
+      results.push(a);
+      if (left <= 1) return results;
+      return wait().then(() => run(left - 1));
+    });
+    return run(times);
+  });
+  Task2.repeatUntil = (options) => (task) => (0, Task2.from)(() => {
+    const { when: predicate, delay: ms } = options;
+    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+    const run = () => toPromise(task).then((a) => {
+      if (predicate(a)) return a;
+      return wait().then(run);
+    });
+    return run();
+  });
+  Task2.race = (tasks) => (0, Task2.from)(() => Promise.race(tasks.map(toPromise)));
+  Task2.sequential = (tasks) => (0, Task2.from)(async () => {
+    const results = [];
+    for (const task of tasks) {
+      results.push(await toPromise(task));
+    }
+    return results;
+  });
+  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)(() => {
+    let timerId;
+    return Promise.race([
+      toPromise(task).then((a) => {
+        clearTimeout(timerId);
+        return Result.ok(a);
+      }),
+      new Promise((resolve2) => {
+        timerId = setTimeout(() => resolve2(Result.err(onTimeout())), ms);
+      })
+    ]);
+  });
+})(Task || (Task = {}));
+
+// src/Core/TaskOption.ts
+var TaskOption;
+((TaskOption2) => {
+  TaskOption2.some = (value) => Task.resolve(Option.some(value));
+  TaskOption2.none = () => Task.resolve(Option.none());
+  TaskOption2.fromOption = (option) => Task.resolve(option);
+  TaskOption2.fromTask = (task) => Task.map(Option.some)(task);
+  TaskOption2.tryCatch = (f) => Task.from(
+    () => f().then(Option.some).catch(() => Option.none())
+  );
+  TaskOption2.map = (f) => (data) => Task.map(Option.map(f))(data);
+  TaskOption2.chain = (f) => (data) => Task.chain((option) => Option.isSome(option) ? f(option.value) : Task.resolve(Option.none()))(data);
+  TaskOption2.ap = (arg) => (data) => Task.from(
+    () => Promise.all([
+      Deferred.toPromise(data()),
+      Deferred.toPromise(arg())
+    ]).then(([of_, oa]) => Option.ap(oa)(of_))
+  );
+  TaskOption2.fold = (onNone, onSome) => (data) => Task.map(Option.fold(onNone, onSome))(data);
+  TaskOption2.match = (cases) => (data) => Task.map(Option.match(cases))(data);
+  TaskOption2.getOrElse = (defaultValue) => (data) => Task.map(Option.getOrElse(defaultValue))(data);
+  TaskOption2.tap = (f) => (data) => Task.map(Option.tap(f))(data);
+  TaskOption2.filter = (predicate) => (data) => Task.map(Option.filter(predicate))(data);
+  TaskOption2.toTaskResult = (onNone) => (data) => Task.map(Option.toResult(onNone))(data);
+})(TaskOption || (TaskOption = {}));
+
+// src/Core/TaskResult.ts
+var TaskResult;
+((TaskResult2) => {
+  TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
+  TaskResult2.err = (error) => Task.resolve(Result.err(error));
+  TaskResult2.tryCatch = (f, onError) => Task.from(
+    () => f().then(Result.ok).catch((e) => Result.err(onError(e)))
+  );
+  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.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.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.retry = (options) => (data) => Task.from(() => {
+    const { attempts, backoff, when: shouldRetry } = options;
+    const getDelay = (n) => backoff === void 0 ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
+    const run = (left) => Deferred.toPromise(data()).then((result) => {
+      if (Result.isOk(result)) return result;
+      if (left <= 1) return result;
+      if (shouldRetry !== void 0 && !shouldRetry(result.error)) {
+        return result;
+      }
+      const ms = getDelay(attempts - left + 1);
+      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(left - 1));
+    });
+    return run(attempts);
+  });
+  TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from(() => {
+    let timerId;
+    return Promise.race([
+      Deferred.toPromise(data()).then((result) => {
+        clearTimeout(timerId);
+        return result;
+      }),
+      new Promise((resolve) => {
+        timerId = setTimeout(() => resolve(Result.err(onTimeout())), ms);
+      })
+    ]);
+  });
+})(TaskResult || (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.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : 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();
+  Validation2.tap = (f) => (data) => {
+    if ((0, Validation2.isValid)(data)) f(data.value);
+    return data;
+  };
+  Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (blockedErrors, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some((err) => blockedErrors.includes(err)) ? fallback() : data;
+  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);
+  };
+  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);
+    }
+    return errors.length > 0 ? (0, Validation2.invalidAll)(errors) : (0, Validation2.valid)(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.fromValidation = (validation) => Task.resolve(validation);
+  TaskValidation2.tryCatch = (f, onError) => Task.from(
+    () => f().then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
+  );
+  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
+  TaskValidation2.ap = (arg) => (data) => Task.from(
+    () => Promise.all([
+      Deferred.toPromise(data()),
+      Deferred.toPromise(arg())
+    ]).then(([vf, va]) => Validation.ap(va)(vf))
+  );
+  TaskValidation2.fold = (onInvalid, onValid) => (data) => Task.map(Validation.fold(onInvalid, onValid))(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)
+  )(data);
+  TaskValidation2.product = (first, second) => Task.from(
+    () => Promise.all([
+      Deferred.toPromise(first()),
+      Deferred.toPromise(second())
+    ]).then(([va, vb]) => Validation.product(va, vb))
+  );
+  TaskValidation2.productAll = (data) => Task.from(
+    () => Promise.all(data.map((t) => Deferred.toPromise(t()))).then((results) => Validation.productAll(results))
+  );
+})(TaskValidation || (TaskValidation = {}));
+
+// src/Core/These.ts
+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.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));
+    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));
+    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));
+    return (0, These2.both)(onFirst(data.first), onSecond(data.second));
+  };
+  These2.chainFirst = (f) => (data) => {
+    if ((0, These2.isSecond)(data)) return data;
+    return f(data.first);
+  };
+  These2.chainSecond = (f) => (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);
+    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);
+    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);
+    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);
+    return (0, These2.both)(data.second, data.first);
+  };
+})(These || (These = {}));
+
+// src/Core/Tuple.ts
+var Tuple;
+((Tuple2) => {
+  Tuple2.make = (first2, second2) => [first2, second2];
+  Tuple2.first = (tuple) => tuple[0];
+  Tuple2.second = (tuple) => tuple[1];
+  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
+  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
+  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
+    onFirst(tuple[0]),
+    onSecond(tuple[1])
+  ];
+  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
+  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
+  Tuple2.toArray = (tuple) => [...tuple];
+  Tuple2.tap = (f) => (tuple) => {
+    f(tuple[0], tuple[1]);
+    return 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;
+
+// src/Utils/Arr.ts
+var Arr;
+((Arr2) => {
+  Arr2.head = (data) => data.length > 0 ? Option.some(data[0]) : Option.none();
+  Arr2.last = (data) => data.length > 0 ? Option.some(data[data.length - 1]) : Option.none();
+  Arr2.tail = (data) => data.length > 0 ? Option.some(data.slice(1)) : Option.none();
+  Arr2.init = (data) => data.length > 0 ? Option.some(data.slice(0, -1)) : Option.none();
+  Arr2.findFirst = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx >= 0 ? Option.some(data[idx]) : Option.none();
+  };
+  Arr2.findLast = (predicate) => (data) => {
+    for (let i = data.length - 1; i >= 0; i--) {
+      if (predicate(data[i])) return Option.some(data[i]);
+    }
+    return Option.none();
+  };
+  Arr2.findIndex = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx >= 0 ? Option.some(idx) : Option.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]);
+    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]);
+    }
+    return result;
+  };
+  Arr2.partition = (predicate) => (data) => {
+    const pass = [];
+    const fail = [];
+    for (const a of data) {
+      (predicate(a) ? pass : fail).push(a);
+    }
+    return [pass, fail];
+  };
+  Arr2.groupBy = (f) => (data) => {
+    const result = {};
+    for (const a of data) {
+      const key = f(a);
+      if (!result[key]) result[key] = [];
+      result[key].push(a);
+    }
+    return result;
+  };
+  Arr2.uniq = (data) => [
+    ...new Set(data)
+  ];
+  Arr2.uniqBy = (f) => (data) => {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const a of data) {
+      const key = f(a);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(a);
+      }
+    }
+    return result;
+  };
+  Arr2.sortBy = (compare) => (data) => [...data].sort(compare);
+  Arr2.zip = (other) => (data) => {
+    const len = Math.min(data.length, other.length);
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = [data[i], other[i]];
+    }
+    return result;
+  };
+  Arr2.zipWith = (f) => (other) => (data) => {
+    const len = Math.min(data.length, other.length);
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = f(data[i], other[i]);
+    }
+    return result;
+  };
+  Arr2.intersperse = (sep) => (data) => {
+    if (data.length <= 1) return data;
+    const result = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      result.push(sep, data[i]);
+    }
+    return result;
+  };
+  Arr2.chunksOf = (n) => (data) => {
+    if (n <= 0) return [];
+    const result = [];
+    for (let i = 0; i < data.length; i += n) {
+      result.push(data.slice(i, i + n));
+    }
+    return result;
+  };
+  Arr2.flatten = (data) => [].concat(...data);
+  Arr2.flatMap = (f) => (data) => {
+    const n = data.length;
+    const result = [];
+    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]);
+    }
+    return result;
+  };
+  Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
+  Arr2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "None") return Option.none();
+      result[i] = mapped.value;
+    }
+    return Option.some(result);
+  };
+  Arr2.traverseResult = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Error") return mapped;
+      result[i] = mapped.value;
+    }
+    return Result.ok(result);
+  };
+  Arr2.traverseTask = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
+  Arr2.sequence = (data) => (0, Arr2.traverse)((a) => a)(data);
+  Arr2.sequenceResult = (data) => (0, Arr2.traverseResult)((a) => a)(data);
+  Arr2.sequenceTask = (data) => (0, Arr2.traverseTask)((a) => a)(data);
+  Arr2.traverseTaskResult = (f) => (data) => Task.from(async () => {
+    const result = [];
+    for (const a of data) {
+      const r = await Deferred.toPromise(f(a)());
+      if (Result.isErr(r)) return r;
+      result.push(r.value);
+    }
+    return Result.ok(result);
+  });
+  Arr2.sequenceTaskResult = (data) => (0, Arr2.traverseTaskResult)((a) => a)(data);
+  Arr2.isNonEmpty = (data) => isNonEmptyList(data);
+  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;
+    return false;
+  };
+  Arr2.every = (predicate) => (data) => {
+    const n = data.length;
+    for (let i = 0; i < n; i++) if (!predicate(data[i])) return false;
+    return true;
+  };
+  Arr2.reverse = (data) => [...data].reverse();
+  Arr2.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
+  Arr2.drop = (n) => (data) => data.slice(n);
+  Arr2.takeWhile = (predicate) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!predicate(a)) break;
+      result.push(a);
+    }
+    return result;
+  };
+  Arr2.dropWhile = (predicate) => (data) => {
+    let i = 0;
+    while (i < data.length && predicate(data[i])) i++;
+    return data.slice(i);
+  };
+  Arr2.scan = (initial, f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    let acc = initial;
+    for (let i = 0; i < n; i++) {
+      acc = f(acc, data[i]);
+      result[i] = acc;
+    }
+    return result;
+  };
+  Arr2.splitAt = (index) => (data) => {
+    const i = Math.max(0, index);
+    return [data.slice(0, i), data.slice(i)];
+  };
+})(Arr || (Arr = {}));
+
+// src/Utils/Dict.ts
+var Dict;
+((Dict2) => {
+  Dict2.empty = () => new globalThis.Map();
+  Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  Dict2.fromEntries = (entries2) => new globalThis.Map(entries2);
+  Dict2.fromRecord = (rec) => new globalThis.Map(Object.entries(rec));
+  Dict2.groupBy = (keyFn) => (items) => {
+    const result = new globalThis.Map();
+    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]);
+    }
+    return result;
+  };
+  Dict2.has = (key) => (m) => m.has(key);
+  Dict2.lookup = (key) => (m) => m.has(key) ? Option.some(m.get(key)) : Option.none();
+  Dict2.size = (m) => m.size;
+  Dict2.isEmpty = (m) => m.size === 0;
+  Dict2.keys = (m) => [...m.keys()];
+  Dict2.values = (m) => [...m.values()];
+  Dict2.entries = (m) => [...m.entries()];
+  Dict2.insert = (key, value) => (m) => {
+    const result = new globalThis.Map(m);
+    result.set(key, value);
+    return result;
+  };
+  Dict2.remove = (key) => (m) => {
+    if (!m.has(key)) return m;
+    const result = new globalThis.Map(m);
+    result.delete(key);
+    return result;
+  };
+  Dict2.upsert = (key, f) => (m) => {
+    const result = new globalThis.Map(m);
+    result.set(key, f((0, Dict2.lookup)(key)(m)));
+    return result;
+  };
+  Dict2.map = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      result.set(k, f(v));
+    }
+    return result;
+  };
+  Dict2.mapWithKey = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      result.set(k, f(k, v));
+    }
+    return result;
+  };
+  Dict2.filter = (predicate) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      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);
+    }
+    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);
+    }
+    return result;
+  };
+  Dict2.union = (other) => (m) => {
+    const result = new globalThis.Map(m);
+    for (const [k, v] of other) {
+      result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.intersection = (other) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      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);
+    }
+    return result;
+  };
+  Dict2.reduce = (init, f) => (m) => {
+    let acc = init;
+    for (const v of m.values()) {
+      acc = f(acc, v);
+    }
+    return acc;
+  };
+  Dict2.reduceWithKey = (init, f) => (m) => {
+    let acc = init;
+    for (const [k, v] of m) {
+      acc = f(acc, v, k);
+    }
+    return acc;
+  };
+  Dict2.toRecord = (m) => Object.fromEntries(m);
+})(Dict || (Dict = {}));
+
+// src/Utils/Num.ts
+var Num;
+((Num2) => {
+  Num2.range = (from, to, step = 1) => {
+    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++) {
+      result[i] = from + i * step;
+    }
+    return result;
+  };
+  Num2.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
+  Num2.between = (min, max) => (n) => n >= min && n <= max;
+  Num2.parse = (s) => {
+    if (s.trim() === "") return Option.none();
+    const n = Number(s);
+    return isNaN(n) ? Option.none() : Option.some(n);
+  };
+  Num2.add = (b) => (a) => a + b;
+  Num2.subtract = (b) => (a) => a - b;
+  Num2.multiply = (b) => (a) => a * b;
+  Num2.divide = (b) => (a) => a / b;
+})(Num || (Num = {}));
+
+// src/Utils/Rec.ts
+var Rec;
+((Rec2) => {
+  Rec2.map = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    const vals = Object.values(data);
+    const result = {};
+    for (let i = 0; i < keys2.length; i++) {
+      result[keys2[i]] = f(vals[i]);
+    }
+    return result;
+  };
+  Rec2.mapWithKey = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    const vals = Object.values(data);
+    const result = {};
+    for (let i = 0; i < keys2.length; i++) {
+      result[keys2[i]] = f(keys2[i], vals[i]);
+    }
+    return result;
+  };
+  Rec2.filter = (predicate) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (predicate(v)) result[k] = v;
+    }
+    return result;
+  };
+  Rec2.filterWithKey = (predicate) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (predicate(k, v)) result[k] = v;
+    }
+    return result;
+  };
+  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? Option.some(data[key]) : Option.none();
+  Rec2.keys = (data) => Object.keys(data);
+  Rec2.values = (data) => Object.values(data);
+  Rec2.entries = (data) => Object.entries(data);
+  Rec2.fromEntries = (data) => Object.fromEntries(data);
+  Rec2.groupBy = (keyFn) => (items) => {
+    const result = {};
+    for (const item of items) {
+      const key = keyFn(item);
+      if (key in result) result[key].push(item);
+      else result[key] = [item];
+    }
+    return result;
+  };
+  Rec2.pick = (...pickedKeys) => (data) => {
+    const result = {};
+    for (const key of pickedKeys) {
+      if (Object.hasOwn(data, key)) {
+        result[key] = data[key];
+      }
+    }
+    return result;
+  };
+  Rec2.omit = (...omittedKeys) => (data) => {
+    const omitSet = new Set(omittedKeys);
+    const result = {};
+    for (const key of Object.keys(data)) {
+      if (!omitSet.has(key)) {
+        result[key] = data[key];
+      }
+    }
+    return result;
+  };
+  Rec2.merge = (other) => (data) => ({
+    ...data,
+    ...other
+  });
+  Rec2.isEmpty = (data) => Object.keys(data).length === 0;
+  Rec2.size = (data) => Object.keys(data).length;
+  Rec2.mapKeys = (f) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      result[f(k)] = v;
+    }
+    return result;
+  };
+  Rec2.compact = (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (v.kind === "Some") result[k] = v.value;
+    }
+    return result;
+  };
+})(Rec || (Rec = {}));
+
+// src/Utils/Str.ts
+var Str;
+((Str2) => {
+  Str2.split = (separator) => (s) => s.split(separator);
+  Str2.trim = (s) => s.trim();
+  Str2.includes = (substring) => (s) => s.includes(substring);
+  Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
+  Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
+  Str2.toUpperCase = (s) => s.toUpperCase();
+  Str2.toLowerCase = (s) => s.toLowerCase();
+  Str2.lines = (s) => s.split(/\r?\n|\r/);
+  Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
+  Str2.parse = {
+    /**
+     * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Str.parse.int("42");   // Some(42)
+     * Str.parse.int("3.7");  // Some(3)
+     * Str.parse.int("abc");  // None
+     * ```
+     */
+    int: (s) => {
+      const n = parseInt(s, 10);
+      return isNaN(n) ? Option.none() : Option.some(n);
+    },
+    /**
+     * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Str.parse.float("3.14"); // Some(3.14)
+     * Str.parse.float("42");   // Some(42)
+     * Str.parse.float("abc");  // None
+     * ```
+     */
+    float: (s) => {
+      const n = parseFloat(s);
+      return isNaN(n) ? Option.none() : Option.some(n);
+    }
+  };
+})(Str || (Str = {}));
+
+// src/Utils/Uniq.ts
+var Uniq;
+((Uniq2) => {
+  Uniq2.empty = () => new globalThis.Set();
+  Uniq2.singleton = (item) => new globalThis.Set([item]);
+  Uniq2.fromArray = (arr) => new globalThis.Set(arr);
+  Uniq2.has = (item) => (s) => s.has(item);
+  Uniq2.size = (s) => s.size;
+  Uniq2.isEmpty = (s) => s.size === 0;
+  Uniq2.isSubsetOf = (other) => (s) => {
+    const set = s;
+    if (typeof set.isSubsetOf === "function") return set.isSubsetOf(other);
+    for (const item of s) {
+      if (!other.has(item)) return false;
+    }
+    return true;
+  };
+  Uniq2.insert = (item) => (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;
+    const result = new globalThis.Set(s);
+    result.delete(item);
+    return result;
+  };
+  Uniq2.map = (f) => (s) => {
+    const result = new globalThis.Set();
+    for (const item of s) {
+      result.add(f(item));
+    }
+    return result;
+  };
+  Uniq2.filter = (predicate) => (s) => {
+    const result = new globalThis.Set();
+    for (const item of s) {
+      if (predicate(item)) result.add(item);
+    }
+    return result;
+  };
+  Uniq2.union = (other) => (s) => {
+    const set = s;
+    if (typeof set.union === "function") return set.union(other);
+    const result = new globalThis.Set(s);
+    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);
+    const result = new globalThis.Set();
+    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);
+    const result = new globalThis.Set();
+    for (const item of s) if (!other.has(item)) result.add(item);
+    return result;
+  };
+  Uniq2.reduce = (init, f) => (s) => {
+    let acc = init;
+    for (const item of s) {
+      acc = f(acc, item);
+    }
+    return acc;
+  };
+  Uniq2.toArray = (s) => [...s];
+})(Uniq || (Uniq = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Arr,
+  Brand,
+  Deferred,
+  Dict,
+  Lens,
+  Logged,
+  Num,
+  Option,
+  Optional,
+  Predicate,
+  Reader,
+  Rec,
+  Refinement,
+  RemoteData,
+  Result,
+  State,
+  Str,
+  Task,
+  TaskOption,
+  TaskResult,
+  TaskValidation,
+  These,
+  Tuple,
+  Uniq,
+  Validation,
+  and,
+  compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  converge,
+  curry,
+  curry3,
+  curry4,
+  flip,
+  flow,
+  identity,
+  isNonEmptyList,
+  juxt,
+  memoize,
+  memoizeWeak,
+  not,
+  on,
+  once,
+  or,
+  pipe,
+  tap,
+  uncurry,
+  uncurry3,
+  uncurry4
+});