@nlozgachev/pipelined 0.58.0 → 0.59.0

package/dist/index.mjs

@@ -0,0 +1,4432 @@
+// src/Composition/compose.ts
+function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
+  const len = arguments.length;
+  switch (len) {
+    case 1: {
+      return f0;
+    }
+    case 2: {
+      return function() {
+        return f0(f1.apply(this, arguments));
+      };
+    }
+    case 3: {
+      return function() {
+        return f0(f1(f2.apply(this, arguments)));
+      };
+    }
+    case 4: {
+      return function() {
+        return f0(f1(f2(f3.apply(this, arguments))));
+      };
+    }
+    case 5: {
+      return function() {
+        return f0(f1(f2(f3(f4.apply(this, arguments)))));
+      };
+    }
+    case 6: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5.apply(this, arguments))))));
+      };
+    }
+    case 7: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6.apply(this, arguments)))))));
+      };
+    }
+    case 8: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6(f7.apply(this, arguments))))))));
+      };
+    }
+    case 9: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6(f7(f8.apply(this, arguments)))))))));
+      };
+    }
+    case 10: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6(f7(f8(f9.apply(this, arguments))))))))));
+      };
+    }
+  }
+}
+
+// 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(ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
+  const len = arguments.length;
+  switch (len) {
+    case 0: {
+      return function(...args) {
+        return args[0];
+      };
+    }
+    case 1: {
+      return ab;
+    }
+    case 2: {
+      return function() {
+        return bc(ab.apply(this, arguments));
+      };
+    }
+    case 3: {
+      return function() {
+        return cd(bc(ab.apply(this, arguments)));
+      };
+    }
+    case 4: {
+      return function() {
+        return de(cd(bc(ab.apply(this, arguments))));
+      };
+    }
+    case 5: {
+      return function() {
+        return ef(de(cd(bc(ab.apply(this, arguments)))));
+      };
+    }
+    case 6: {
+      return function() {
+        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+      };
+    }
+    case 7: {
+      return function() {
+        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+      };
+    }
+    case 8: {
+      return function() {
+        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+      };
+    }
+    case 9: {
+      return function() {
+        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+      };
+    }
+    case 10: {
+      return function() {
+        return jk(ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))));
+      };
+    }
+  }
+}
+var when = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+var unless = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+var either = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+var struct = (fields) => (a) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = fields[key](a);
+  }
+  return result;
+};
+function safe(...fns) {
+  return (a) => {
+    let result = a;
+    if (result === null || result === void 0) {
+      return result;
+    }
+    for (const fn of fns) {
+      result = fn(result);
+      if (result === null || result === void 0) {
+        return result;
+      }
+    }
+    return result;
+  };
+}
+function async(...fns) {
+  return async (a) => {
+    let result = await a;
+    for (const fn of fns) {
+      result = await fn(result);
+    }
+    return result;
+  };
+}
+flow.when = when;
+flow.unless = unless;
+flow.either = either;
+flow.struct = struct;
+flow.safe = safe;
+flow.async = async;
+flow.try = (f, onError) => (a) => {
+  try {
+    return f(a);
+  } catch (error) {
+    return onError(error, a);
+  }
+};
+
+// 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;
+  };
+};
+var defaultTo = (fallback) => (a) => a === null || a === void 0 ? fallback : a;
+var tuple = (f) => (args) => f(...args);
+var untuple = (f) => (...args) => f(args);
+
+// src/Composition/juxt.ts
+function juxt(fns) {
+  return (a) => fns.map((f) => f(a));
+}
+
+// src/Composition/memoize.ts
+var memoize = (f, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const keyFn = options?.key ?? ((a) => a);
+  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, ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
+  switch (arguments.length) {
+    case 1: {
+      return a;
+    }
+    case 2: {
+      return ab(a);
+    }
+    case 3: {
+      return bc(ab(a));
+    }
+    case 4: {
+      return cd(bc(ab(a)));
+    }
+    case 5: {
+      return de(cd(bc(ab(a))));
+    }
+    case 6: {
+      return ef(de(cd(bc(ab(a)))));
+    }
+    case 7: {
+      return fg(ef(de(cd(bc(ab(a))))));
+    }
+    case 8: {
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    }
+    case 9: {
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    }
+    case 10: {
+      return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
+    }
+    case 11: {
+      return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
+    }
+  }
+}
+var when2 = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+var unless2 = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+var either2 = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+var struct2 = (fields) => (a) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = fields[key](a);
+  }
+  return result;
+};
+function safe2(a, ...fns) {
+  let result = a;
+  if (result === null || result === void 0) {
+    return result;
+  }
+  for (const fn of fns) {
+    result = fn(result);
+    if (result === null || result === void 0) {
+      return result;
+    }
+  }
+  return result;
+}
+async function async2(a, ...fns) {
+  let result = await a;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+pipe.when = when2;
+pipe.unless = unless2;
+pipe.either = either2;
+pipe.struct = struct2;
+pipe.safe = safe2;
+pipe.async = async2;
+pipe.try = (f, onError) => (a) => {
+  try {
+    return f(a);
+  } catch (error) {
+    return onError(error, a);
+  }
+};
+
+// src/Composition/tap.ts
+import { inspect as nodeInspect } from "util";
+
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/RetryPolicy.ts
+var RetryPolicy;
+((RetryPolicy2) => {
+  RetryPolicy2.constant = (options) => ({
+    attempts: Math.max(1, options.attempts),
+    getDelay: () => options.delay
+  });
+  RetryPolicy2.exponential = (options) => {
+    const attempts = Math.max(1, options.attempts);
+    const initialMs = Duration.to.milliseconds(options.initial);
+    const factor = options.factor ?? 2;
+    const jitter = options.jitter ?? false;
+    return {
+      attempts,
+      getDelay: (attempt) => {
+        const rawMs = initialMs * factor ** Math.max(0, attempt - 1);
+        const finalMs = jitter ? Math.random() * rawMs : rawMs;
+        return Duration.milliseconds(finalMs);
+      }
+    };
+  };
+})(RetryPolicy || (RetryPolicy = {}));
+
+// 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);
+  let to;
+  ((to2) => {
+    to2.milliseconds = (d) => Brand.unwrap(d);
+    to2.seconds = (d) => Brand.unwrap(d) / 1e3;
+    to2.minutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+    to2.hours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+    to2.days = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  })(to = Duration2.to || (Duration2.to = {}));
+  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/Composition/tap.ts
+function tap(f) {
+  return (a) => {
+    f(a);
+    return a;
+  };
+}
+((tap2) => {
+  tap2.log = (options) => (a) => {
+    const logger = options?.logger ?? console.log;
+    const formatter = options?.formatter ?? ((val) => {
+      try {
+        return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
+      } catch {
+        return String(val);
+      }
+    });
+    const formatted = formatter(a);
+    if (options?.label !== void 0) {
+      logger(`[${options.label}]: ${formatted}`);
+    } else {
+      logger(formatted);
+    }
+    return a;
+  };
+  tap2.inspect = (options) => (a) => {
+    const label = options?.label;
+    const depth = options?.depth ?? null;
+    const colors = options?.colors ?? true;
+    let formatted;
+    if (typeof nodeInspect === "function") {
+      formatted = nodeInspect(a, { depth, colors });
+    } else {
+      try {
+        formatted = JSON.stringify(a, null, 2);
+      } catch {
+        formatted = String(a);
+      }
+    }
+    if (label !== void 0) {
+      console.log(`[${label}]: ${formatted}`);
+    } else {
+      console.log(formatted);
+    }
+    return a;
+  };
+  tap2.async = (fn, options) => (a) => {
+    const onError = options?.onError ?? console.error;
+    Promise.resolve(fn(a)).catch((err2) => {
+      onError(err2);
+    });
+    return a;
+  };
+  tap2.time = (fn, config) => (a) => {
+    const start = performance.now();
+    const triggerFinish = (duration) => {
+      if (config.label !== void 0) {
+        console.log(`[${config.label}]: ${Duration.to.milliseconds(duration)}ms`);
+      } else {
+        config.onFinish(duration);
+      }
+    };
+    try {
+      const res = fn(a);
+      if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
+        res.then(() => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        }, () => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        });
+      } else {
+        const duration = Duration.milliseconds(performance.now() - start);
+        triggerFinish(duration);
+      }
+    } catch (err2) {
+      const duration = Duration.milliseconds(performance.now() - start);
+      triggerFinish(duration);
+      throw err2;
+    }
+    return a;
+  };
+})(tap || (tap = {}));
+
+// 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/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.maybe = (inner) => ({
+    empty: Maybe.make.none(),
+    combine: (b) => (a) => Maybe.is.none(a) ? b : Maybe.is.none(b) ? a : Maybe.make.some(inner.combine(b.value)(a.value))
+  });
+  Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
+  Combinable2.struct = (fields) => {
+    const empty = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        empty[key] = fields[key].empty;
+      }
+    }
+    return {
+      empty,
+      combine: (b) => (a) => {
+        const result = {};
+        for (const key in fields) {
+          if (Object.hasOwn(fields, key)) {
+            result[key] = fields[key].combine(b[key])(a[key]);
+          }
+        }
+        return result;
+      }
+    };
+  };
+})(Combinable || (Combinable = {}));
+
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  let from;
+  ((from2) => {
+    from2.Promise = (p) => (
+      // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+      { then: ((f) => p.then(f)) }
+    );
+  })(from = Deferred2.from || (Deferred2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Promise = (d) => new globalThis.Promise((resolve) => d.then(resolve));
+  })(to = Deferred2.to || (Deferred2.to = {}));
+  Deferred2.all = (deferreds) => from.Promise(globalThis.Promise.all(deferreds.map((d) => to.Promise(d))));
+  Deferred2.race = (deferreds) => from.Promise(globalThis.Promise.race(deferreds.map((d) => to.Promise(d))));
+})(Deferred || (Deferred = {}));
+
+// src/Core/Equality.ts
+var Equality;
+((Equality3) => {
+  Equality3.string = (a, b) => a === b;
+  Equality3.number = (a, b) => a === b;
+  Equality3.boolean = (a, b) => a === b;
+  Equality3.date = (a, b) => a.getTime() === b.getTime();
+  Equality3.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
+  Equality3.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
+  Equality3.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
+  Equality3.struct = (fields) => (a, b) => {
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        if (!fields[key](a[key], b[key])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+  Equality3.tuple = (...equalities) => (a, b) => {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < equalities.length; i++) {
+      if (!equalities[i](a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
+})(Equality || (Equality = {}));
+
+// src/Core/Lazy.ts
+var Lazy;
+((Lazy2) => {
+  Lazy2.from = (f) => {
+    let done = false;
+    let cache;
+    return {
+      get: () => {
+        if (!done) {
+          cache = f();
+          done = true;
+        }
+        return cache;
+      }
+    };
+  };
+  Lazy2.evaluate = (lazy) => lazy.get();
+  Lazy2.map = (f) => (lazy) => Lazy2.from(() => f(lazy.get()));
+  Lazy2.chain = (f) => (lazy) => Lazy2.from(() => f(lazy.get()).get());
+  Lazy2.tap = (f) => (lazy) => Lazy2.from(() => {
+    const v = lazy.get();
+    f(v);
+    return v;
+  });
+})(Lazy || (Lazy = {}));
+
+// src/Core/Lens.ts
+var Lens;
+((Lens3) => {
+  let from;
+  ((from2) => {
+    from2.accessors = (get2, set2) => ({ get: get2, set: set2 });
+    from2.property = () => (key) => (0, from2.accessors)((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
+  })(from = Lens3.from || (Lens3.from = {}));
+  Lens3.get = (lens) => (s) => lens.get(s);
+  Lens3.set = (lens) => (a) => (s) => lens.set(a)(s);
+  Lens3.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
+  Lens3.andThen = (inner) => (outer) => from.accessors((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
+  Lens3.andThenOptional = (inner) => (outer) => ({
+    get: (s) => inner.get(outer.get(s)),
+    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  });
+  Lens3.toOptional = (lens) => ({
+    get: (s) => ({ kind: "Some", value: lens.get(s) }),
+    set: lens.set
+  });
+})(Lens || (Lens = {}));
+
+// src/Core/Logged.ts
+var Logged;
+((Logged2) => {
+  let from;
+  ((from2) => {
+    from2.value = (val) => ({ value: val, log: [] });
+    from2.entry = (logEntry) => ({ value: void 0, log: [logEntry] });
+  })(from = Logged2.from || (Logged2.from = {}));
+  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];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Logged2.focus = (lens) => (f) => (data) => ({
+    value: lens.set(f(lens.get(data.value)))(data.value),
+    log: data.log
+  });
+})(Logged || (Logged = {}));
+
+// src/Core/Maybe.ts
+var _none = { kind: "None" };
+var Maybe;
+((Maybe3) => {
+  let make;
+  ((make2) => {
+    make2.some = (value) => ({ kind: "Some", value });
+    make2.none = () => _none;
+  })(make = Maybe3.make || (Maybe3.make = {}));
+  let is;
+  ((is2) => {
+    is2.some = (data) => data.kind === "Some";
+    is2.none = (data) => data.kind === "None";
+  })(is = Maybe3.is || (Maybe3.is = {}));
+  let to;
+  ((to2) => {
+    to2.nullable = (data) => is.some(data) ? data.value : null;
+    to2.undefined = (data) => is.some(data) ? data.value : globalThis.undefined;
+    to2.Result = (onNone) => (data) => is.some(data) ? Result.make.ok(data.value) : Result.make.err(onNone());
+  })(to = Maybe3.to || (Maybe3.to = {}));
+  let from;
+  ((from2) => {
+    from2.nullable = (value) => value === null || value === void 0 ? make.none() : make.some(value);
+    from2.Predicate = (pred) => (a) => pred(a) ? make.some(a) : make.none();
+    from2.Result = (data) => Result.is.ok(data) ? make.some(data.value) : make.none();
+  })(from = Maybe3.from || (Maybe3.from = {}));
+  Maybe3.map = (f) => (data) => is.some(data) ? make.some(f(data.value)) : data;
+  Maybe3.chain = (f) => (data) => is.some(data) ? f(data.value) : data;
+  Maybe3.fold = (onNone, onSome) => (data) => is.some(data) ? onSome(data.value) : onNone();
+  Maybe3.match = (cases) => (data) => is.some(data) ? cases.some(data.value) : cases.none();
+  Maybe3.getOrElse = (defaultValue) => (data) => is.some(data) ? data.value : defaultValue();
+  Maybe3.tap = (f) => (data) => {
+    if (is.some(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Maybe3.filter = (predicate) => (data) => is.some(data) ? predicate(data.value) ? data : make.none() : data;
+  Maybe3.recover = (fallback) => (data) => is.some(data) ? data : fallback();
+  Maybe3.ap = (arg) => (data) => is.some(data) && is.some(arg) ? make.some(data.value(arg.value)) : make.none();
+  Maybe3.bindTo = (key) => (data) => (0, Maybe3.map)((a) => ({ [key]: a }))(data);
+  Maybe3.bind = (key, f) => (data) => (0, Maybe3.chain)(
+    (a) => (0, Maybe3.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Maybe3.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if (is.none(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return make.some(result);
+  };
+  Maybe3.transposeResult = (data) => is.none(data) ? Result.make.ok(make.none()) : Result.is.ok(data.value) ? Result.make.ok(make.some(data.value.value)) : Result.make.err(data.value.error);
+})(Maybe || (Maybe = {}));
+
+// src/internal/Op.util.ts
+var _abortedNil = { kind: "OpNil", reason: "aborted" };
+var _droppedNil = { kind: "OpNil", reason: "dropped" };
+var _replacedNil = { kind: "OpNil", reason: "replaced" };
+var _evictedNil = { kind: "OpNil", reason: "evicted" };
+var _idle = { kind: "Idle" };
+var _pending = { kind: "Pending" };
+var ok = (value) => ({ kind: "OpOk", value });
+var err = (error) => ({ kind: "OpErr", error });
+var getMs = (duration) => Duration.to.milliseconds(duration);
+var cancellableWait = (duration, signal) => {
+  const rawMs = getMs(duration);
+  if (rawMs <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const id = setTimeout(resolve, rawMs);
+    signal.addEventListener("abort", () => {
+      clearTimeout(id);
+      resolve();
+    }, { once: true });
+  });
+};
+var runWithRetry = (op, input, signal, options, onRetrying) => {
+  const { attempts, backoff, when: shouldRetry } = options;
+  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.to.Promise(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;
+    }
+    const attemptNumber = attempts - left + 1;
+    const delayDuration = getDelay(attemptNumber);
+    const ms = delayDuration ? getMs(delayDuration) : 0;
+    onRetrying({
+      kind: "Retrying",
+      attempt: attemptNumber,
+      lastError: result.error,
+      ...ms > 0 ? { nextRetryIn: ms } : {}
+    });
+    if (delayDuration) {
+      await cancellableWait(delayDuration, signal);
+    }
+    if (signal.aborted) {
+      return null;
+    }
+    return attempt(left - 1);
+  };
+  return attempt(attempts);
+};
+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.to.Promise(op._factory(input, signal)).then(toOutcome);
+  if (timeoutOptions === void 0) {
+    return Deferred.from.Promise(runPromise);
+  }
+  let timerId;
+  return Deferred.from.Promise(Promise.race([
+    runPromise.then((outcome) => {
+      clearTimeout(timerId);
+      return outcome;
+    }),
+    new Promise((resolve) => {
+      timerId = setTimeout(() => {
+        controller.abort();
+        resolve(err(timeoutOptions.onTimeout()));
+      }, getMs(timeoutOptions.duration));
+    })
+  ]));
+};
+var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let waitController;
+  let lastStartTime = 0;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const run = (input) => Deferred.from.Promise(
+    new Promise((resolve) => {
+      waitController?.abort();
+      waitController = void 0;
+      currentController?.abort();
+      const prev = currentResolve;
+      currentResolve = resolve;
+      currentController = new AbortController();
+      const controller = currentController;
+      prev?.(_replacedNil);
+      const startExecution = () => {
+        if (currentController !== controller) {
+          return;
+        }
+        lastStartTime = Date.now();
+        emit(_pending);
+        const onRetrying = retryOptions ? (r) => {
+          if (currentController === controller) {
+            emit(r);
+          }
+        } : void 0;
+        execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+          if (currentController !== controller) {
+            return;
+          }
+          const r = currentResolve;
+          currentResolve = void 0;
+          currentController = void 0;
+          emit(outcome);
+          r?.(outcome);
+        });
+      };
+      const gap = minInterval !== void 0 ? Math.max(0, getMs(minInterval) - (Date.now() - lastStartTime)) : 0;
+      if (gap > 0) {
+        waitController = new AbortController();
+        const wc = waitController;
+        cancellableWait(Duration.milliseconds(gap), wc.signal).then(() => {
+          if (waitController === wc) {
+            waitController = void 0;
+          }
+          startExecution();
+        });
+      } else {
+        startExecution();
+      }
+    })
+  );
+  const abort = () => {
+    waitController?.abort();
+    waitController = void 0;
+    currentController?.abort();
+    currentController = void 0;
+    const r = currentResolve;
+    currentResolve = void 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    r?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let cooldownTimer;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const run = (input) => {
+    if (currentController !== void 0 || cooldownTimer !== void 0) {
+      return Deferred.from.Promise(Promise.resolve(_droppedNil));
+    }
+    return Deferred.from.Promise(
+      new Promise((resolve) => {
+        currentResolve = resolve;
+        currentController = new AbortController();
+        const controller = currentController;
+        emit(_pending);
+        const onRetrying = retryOptions ? (r) => {
+          if (currentController === controller) {
+            emit(r);
+          }
+        } : void 0;
+        execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+          if (currentController !== controller) {
+            return;
+          }
+          const r = currentResolve;
+          currentResolve = void 0;
+          currentController = void 0;
+          emit(outcome);
+          r?.(outcome);
+          if (cooldown !== void 0) {
+            const rawCooldown = getMs(cooldown);
+            if (rawCooldown > 0) {
+              cooldownTimer = setTimeout(() => {
+                cooldownTimer = void 0;
+              }, rawCooldown);
+            }
+          }
+        });
+      })
+    );
+  };
+  const abort = () => {
+    if (cooldownTimer !== void 0) {
+      clearTimeout(cooldownTimer);
+      cooldownTimer = void 0;
+    }
+    currentController?.abort();
+    currentController = void 0;
+    const r = currentResolve;
+    currentResolve = void 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    r?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeoutOptions) => {
+  const maxConcurrency = concurrency ?? 1;
+  let currentState = _idle;
+  let generation = 0;
+  let inFlight = 0;
+  const queue = [];
+  const inflightControllers = /* @__PURE__ */ new Set();
+  const inflightResolvers = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const startOne = (input, resolve, myGeneration) => {
+    inFlight++;
+    const controller = new AbortController();
+    inflightControllers.add(controller);
+    inflightResolvers.push(resolve);
+    emit(_pending);
+    const onRetrying = retryOptions ? (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 (generation !== myGeneration) {
+        resolve(_abortedNil);
+        return;
+      }
+      inFlight--;
+      emit(outcome);
+      resolve(outcome);
+      if (queue.length > 0) {
+        const next = queue.shift();
+        startOne(next.input, next.resolve, generation);
+      }
+    });
+  };
+  const run = (input) => {
+    const myGeneration = generation;
+    if (dedupe !== void 0) {
+      const idx = queue.findIndex((item) => dedupe(input, item.input));
+      if (idx !== -1) {
+        const dup = queue.splice(idx, 1)[0];
+        dup.resolve(_droppedNil);
+      }
+    }
+    if (inFlight < maxConcurrency) {
+      return Deferred.from.Promise(
+        new Promise((resolve) => {
+          startOne(input, resolve, myGeneration);
+        })
+      );
+    }
+    if (maxSize === void 0 || queue.length < maxSize) {
+      return Deferred.from.Promise(
+        new Promise((resolve) => {
+          queue.push({ input, resolve });
+          emit({ kind: "Queued", position: queue.length - 1 });
+        })
+      );
+    }
+    if (overflow === "replace-last") {
+      return Deferred.from.Promise(
+        new Promise((resolve) => {
+          const tail = queue.pop();
+          tail.resolve(_evictedNil);
+          queue.push({ input, resolve });
+          emit({ kind: "Queued", position: queue.length - 1 });
+        })
+      );
+    }
+    return Deferred.from.Promise(Promise.resolve(_droppedNil));
+  };
+  const abort = () => {
+    generation++;
+    inflightControllers.forEach((c) => c.abort());
+    inflightControllers.clear();
+    const toResolve = inflightResolvers.splice(0);
+    const queuedResolvers = queue.splice(0).map((item) => item.resolve);
+    inFlight = 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    toResolve.forEach((r) => r(_abortedNil));
+    queuedResolvers.forEach((r) => r(_abortedNil));
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
+  const bufferSize = size ?? 1;
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  const buffer = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const startRun = (input, resolve) => {
+    currentResolve = resolve;
+    currentController = new AbortController();
+    const controller = currentController;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (currentController === controller) {
+        emit(r);
+      }
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (currentController !== controller) {
+        return;
+      }
+      const r = currentResolve;
+      currentResolve = void 0;
+      currentController = void 0;
+      emit(outcome);
+      r?.(outcome);
+      if (buffer.length > 0) {
+        const next = buffer.shift();
+        startRun(next.input, next.resolve);
+      }
+    });
+  };
+  const run = (input) => Deferred.from.Promise(
+    new Promise((resolve) => {
+      if (currentController === void 0) {
+        startRun(input, resolve);
+      } else if (buffer.length < bufferSize) {
+        buffer.push({ input, resolve });
+        emit({ kind: "Queued", position: buffer.length - 1 });
+      } else {
+        const evicted = buffer.shift();
+        evicted.resolve(_evictedNil);
+        buffer.push({ input, resolve });
+        emit({ kind: "Queued", position: buffer.length - 1 });
+      }
+    })
+  );
+  const abort = () => {
+    currentController?.abort();
+    currentController = void 0;
+    const cr = currentResolve;
+    currentResolve = void 0;
+    const bufferedResolvers = buffer.splice(0).map((item) => item.resolve);
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    cr?.(_abortedNil);
+    bufferedResolvers.forEach((r) => r(_abortedNil));
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeDebounced = (op, duration, leading, maxWait, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let leadingController;
+  let leadingResolve;
+  let pendingResolve;
+  let timerId;
+  let pendingInput;
+  let firstCallAt = 0;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const fireLeading = (input, resolve) => {
+    leadingController = new AbortController();
+    const controller = leadingController;
+    leadingResolve = resolve;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (leadingController === controller) {
+        emit(r);
+      }
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (leadingController !== controller) {
+        return;
+      }
+      const r = leadingResolve;
+      leadingResolve = void 0;
+      leadingController = void 0;
+      emit(outcome);
+      r?.(outcome);
+    });
+  };
+  const fireTrailing = () => {
+    timerId = void 0;
+    firstCallAt = 0;
+    const capturedResolve = pendingResolve;
+    pendingResolve = void 0;
+    if (capturedResolve === void 0) {
+      return;
+    }
+    currentResolve = capturedResolve;
+    const toRun = pendingInput;
+    pendingInput = void 0;
+    currentController = new AbortController();
+    const controller = currentController;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (currentController === controller) {
+        emit(r);
+      }
+    } : void 0;
+    execute(op, toRun, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (currentController !== controller) {
+        return;
+      }
+      const r = currentResolve;
+      currentResolve = void 0;
+      currentController = void 0;
+      emit(outcome);
+      r?.(outcome);
+    });
+  };
+  const scheduleTrailing = () => {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    let delay = getMs(duration);
+    if (maxWait !== void 0 && firstCallAt > 0) {
+      const maxDelay = firstCallAt + getMs(maxWait) - Date.now();
+      delay = Math.min(getMs(duration), Math.max(0, maxDelay));
+    }
+    timerId = setTimeout(fireTrailing, delay);
+  };
+  const inDebounceWindow = () => timerId !== void 0 || leadingController !== void 0 || currentController !== void 0;
+  const run = (input) => Deferred.from.Promise(
+    new Promise((resolve) => {
+      if (!inDebounceWindow()) {
+        firstCallAt = Date.now();
+        if (leading) {
+          fireLeading(input, resolve);
+          scheduleTrailing();
+        } else {
+          pendingInput = input;
+          pendingResolve = resolve;
+          scheduleTrailing();
+        }
+      } else {
+        const prev = pendingResolve;
+        pendingInput = input;
+        pendingResolve = resolve;
+        prev?.(_evictedNil);
+        scheduleTrailing();
+      }
+    })
+  );
+  const abort = () => {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+      timerId = void 0;
+      pendingInput = void 0;
+      firstCallAt = 0;
+    }
+    const pr = pendingResolve;
+    pendingResolve = void 0;
+    const cr = currentResolve;
+    currentResolve = void 0;
+    currentController?.abort();
+    currentController = void 0;
+    const lr = leadingResolve;
+    leadingResolve = void 0;
+    leadingController?.abort();
+    leadingController = void 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    pr?.(_abortedNil);
+    cr?.(_abortedNil);
+    lr?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let cooldownTimer;
+  let pendingInput;
+  let pendingResolve;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const fireOp = (input, resolve) => {
+    currentResolve = resolve;
+    currentController = new AbortController();
+    const controller = currentController;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (currentController === controller) {
+        emit(r);
+      }
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (currentController !== controller) {
+        return;
+      }
+      const r = currentResolve;
+      currentResolve = void 0;
+      currentController = void 0;
+      emit(outcome);
+      r?.(outcome);
+    });
+  };
+  const startCooldown = () => {
+    cooldownTimer = setTimeout(() => {
+      cooldownTimer = void 0;
+      if (trailing && pendingInput !== void 0) {
+        const input = pendingInput;
+        const resolve = pendingResolve;
+        pendingInput = void 0;
+        pendingResolve = void 0;
+        fireOp(input, resolve);
+        startCooldown();
+      }
+    }, getMs(duration));
+  };
+  const run = (input) => {
+    if (cooldownTimer !== void 0) {
+      if (!trailing) {
+        return Deferred.from.Promise(Promise.resolve(_droppedNil));
+      }
+      return Deferred.from.Promise(
+        new Promise((resolve) => {
+          const prev = pendingResolve;
+          pendingInput = input;
+          pendingResolve = resolve;
+          prev?.(_evictedNil);
+        })
+      );
+    }
+    return Deferred.from.Promise(
+      new Promise((resolve) => {
+        fireOp(input, resolve);
+        startCooldown();
+      })
+    );
+  };
+  const abort = () => {
+    if (cooldownTimer !== void 0) {
+      clearTimeout(cooldownTimer);
+      cooldownTimer = void 0;
+    }
+    currentController?.abort();
+    currentController = void 0;
+    const cr = currentResolve;
+    currentResolve = void 0;
+    const pr = pendingResolve;
+    pendingResolve = void 0;
+    pendingInput = void 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    cr?.(_abortedNil);
+    pr?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let inflight = 0;
+  let generation = 0;
+  const controllers = /* @__PURE__ */ new Set();
+  const inflightResolvers = [];
+  const overflowQueue = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const startOne = (input, resolve, myGeneration) => {
+    inflight++;
+    const controller = new AbortController();
+    controllers.add(controller);
+    inflightResolvers.push(resolve);
+    emit(_pending);
+    const onRetrying = retryOptions ? (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 (generation !== myGeneration) {
+        resolve(_abortedNil);
+        return;
+      }
+      inflight--;
+      emit(outcome);
+      resolve(outcome);
+      if (overflowQueue.length > 0) {
+        const next = overflowQueue.shift();
+        startOne(next.input, next.resolve, generation);
+      }
+    });
+  };
+  const run = (input) => {
+    const myGeneration = generation;
+    if (inflight < n) {
+      return Deferred.from.Promise(
+        new Promise((resolve) => {
+          startOne(input, resolve, myGeneration);
+        })
+      );
+    }
+    if (overflow === "drop") {
+      return Deferred.from.Promise(Promise.resolve(_droppedNil));
+    }
+    return Deferred.from.Promise(
+      new Promise((resolve) => {
+        overflowQueue.push({ input, resolve });
+        emit({ kind: "Queued", position: overflowQueue.length - 1 });
+      })
+    );
+  };
+  const abort = () => {
+    generation++;
+    controllers.forEach((c) => c.abort());
+    controllers.clear();
+    const toResolve = inflightResolvers.splice(0);
+    const queuedResolvers = overflowQueue.splice(0).map((item) => item.resolve);
+    inflight = 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    toResolve.forEach((r) => r(_abortedNil));
+    queuedResolvers.forEach((r) => r(_abortedNil));
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
+  const stateMap = /* @__PURE__ */ new Map();
+  const slots = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  const emitSnapshot = () => {
+    const snapshot = new Map(stateMap);
+    subscribers.forEach((cb) => cb(snapshot));
+  };
+  const run = (input) => {
+    const k = keyFn(input);
+    if (slots.has(k)) {
+      if (perKey === "exclusive") {
+        return Deferred.from.Promise(Promise.resolve(_droppedNil));
+      }
+      const existing = slots.get(k);
+      existing.controller.abort();
+      const prev = existing.resolve;
+      slots.delete(k);
+      prev(_replacedNil);
+    }
+    return Deferred.from.Promise(
+      new Promise((resolve) => {
+        const controller = new AbortController();
+        slots.set(k, { controller, resolve });
+        stateMap.set(k, _pending);
+        emitSnapshot();
+        execute(op, input, controller, void 0, timeoutOptions).then((outcome) => {
+          const slot = slots.get(k);
+          if (!slot || slot.controller !== controller) {
+            resolve(_abortedNil);
+            return;
+          }
+          slots.delete(k);
+          stateMap.set(k, outcome);
+          emitSnapshot();
+          resolve(outcome);
+        });
+      })
+    );
+  };
+  const abort = (key) => {
+    if (key !== void 0) {
+      const slot = slots.get(key);
+      if (slot) {
+        slot.controller.abort();
+        const r = slot.resolve;
+        slots.delete(key);
+        stateMap.set(key, _abortedNil);
+        emitSnapshot();
+        r(_abortedNil);
+      }
+    } else {
+      const toResolve = [];
+      for (const [k, slot] of slots) {
+        slot.controller.abort();
+        toResolve.push(slot.resolve);
+        stateMap.set(k, _abortedNil);
+      }
+      slots.clear();
+      if (toResolve.length > 0) {
+        emitSnapshot();
+      }
+      toResolve.forEach((r) => r(_abortedNil));
+    }
+  };
+  return {
+    get state() {
+      return new Map(stateMap);
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (stateMap.size > 0) {
+        cb(new Map(stateMap));
+      }
+      return () => subscribers.delete(cb);
+    },
+    reset: () => {
+      stateMap.clear();
+      emitSnapshot();
+    },
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+var makeOnce = (op, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const run = (input) => {
+    if (currentState.kind !== "Idle") {
+      return Deferred.from.Promise(Promise.resolve(_droppedNil));
+    }
+    return Deferred.from.Promise(
+      new Promise((resolve) => {
+        currentResolve = resolve;
+        currentController = new AbortController();
+        const controller = currentController;
+        emit(_pending);
+        const onRetrying = retryOptions ? (r) => {
+          if (currentController === controller) {
+            emit(r);
+          }
+        } : void 0;
+        execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+          if (currentController !== controller) {
+            return;
+          }
+          const r = currentResolve;
+          currentResolve = void 0;
+          currentController = void 0;
+          emit(outcome);
+          r?.(outcome);
+        });
+      })
+    );
+  };
+  const abort = () => {
+    currentController?.abort();
+    currentController = void 0;
+    const r = currentResolve;
+    currentResolve = void 0;
+    if (currentState.kind !== "Idle") {
+      emit(_abortedNil);
+    }
+    r?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      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), getMs(interval));
+      return () => clearInterval(id);
+    }
+  };
+};
+
+// src/Core/Op.ts
+var Op;
+((Op2) => {
+  Op2.nil = (reason) => ({ kind: "OpNil", reason });
+  Op2.create = (factory, onError) => ({
+    _factory: (input, signal) => Deferred.from.Promise(
+      factory(signal)(input).then((value) => Result.make.ok(value)).catch((error) => signal.aborted ? null : Result.make.err(onError(error)))
+    )
+  });
+  Op2.lift = (f) => (0, Op2.create)((signal) => (input) => f(input, signal), (e) => e);
+  Op2.ok = (value) => ({ kind: "OpOk", value });
+  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.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 === "OpErr") {
+      return cases.err(outcome.error);
+    }
+    return cases.nil();
+  };
+  Op2.fold = (onErr, onNil, onOk) => (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 === "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);
+    }
+    return outcome;
+  };
+  Op2.recover = (f) => (outcome) => outcome.kind === "OpErr" ? f(outcome.error) : outcome;
+  let to;
+  ((to2) => {
+    to2.Result = (onNil) => (outcome) => {
+      if (outcome.kind === "OpOk") {
+        return Result.make.ok(outcome.value);
+      }
+      if (outcome.kind === "OpErr") {
+        return Result.make.err(outcome.error);
+      }
+      return Result.make.err(onNil());
+    };
+    to2.Maybe = (outcome) => outcome.kind === "OpOk" ? Maybe.make.some(outcome.value) : Maybe.make.none();
+  })(to = Op2.to || (Op2.to = {}));
+  Op2.all = (invocations) => Deferred.from.Promise(Promise.all(invocations.map(Deferred.to.Promise)));
+  Op2.race = (invocations) => Deferred.from.Promise(Promise.race(invocations.map(Deferred.to.Promise)));
+  Op2.wire = (source, f) => source.subscribe((state) => {
+    if ((0, Op2.isOk)(state)) {
+      f(state.value);
+    }
+  });
+  function interpret(op, options) {
+    const { strategy, retry: retryOptions, timeout: timeoutOptions } = options;
+    switch (strategy) {
+      case "once": {
+        return makeOnce(op, retryOptions, timeoutOptions);
+      }
+      case "restartable": {
+        return makeRestartable(op, options.minInterval, retryOptions, timeoutOptions);
+      }
+      case "exclusive": {
+        return makeExclusive(op, options.cooldown, retryOptions, timeoutOptions);
+      }
+      case "queue": {
+        return makeQueue(
+          op,
+          options.maxSize,
+          options.overflow,
+          options.concurrency,
+          options.dedupe,
+          retryOptions,
+          timeoutOptions
+        );
+      }
+      case "buffered": {
+        return makeBuffered(op, options.size, retryOptions, timeoutOptions);
+      }
+      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,
+          options.overflow ?? "drop",
+          retryOptions,
+          timeoutOptions
+        );
+      }
+      case "keyed": {
+        return makeKeyed(op, options.key ?? ((i) => i), options.perKey ?? "exclusive", timeoutOptions);
+      }
+    }
+  }
+  Op2.interpret = interpret;
+})(Op || (Op = {}));
+
+// src/Core/Optional.ts
+var Optional;
+((Optional2) => {
+  let from;
+  ((from2) => {
+    from2.accessors = (get2, set2) => ({
+      get: get2,
+      set: set2
+    });
+    from2.property = () => (key) => (0, from2.accessors)((s) => {
+      const val = s[key];
+      return val !== null && val !== void 0 ? Maybe.make.some(val) : Maybe.make.none();
+    }, (a) => (s) => ({ ...s, [key]: a }));
+  })(from = Optional2.from || (Optional2.from = {}));
+  Optional2.index = (i) => from.accessors((arr) => i >= 0 && i < arr.length ? Maybe.make.some(arr[i]) : Maybe.make.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) => from.accessors((s) => {
+    const mid = outer.get(s);
+    return mid.kind === "None" ? Maybe.make.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) => from.accessors((s) => {
+    const mid = outer.get(s);
+    return mid.kind === "None" ? Maybe.make.none() : Maybe.make.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
+var Ordering;
+((Ordering3) => {
+  Ordering3.string = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  Ordering3.number = (a, b) => a - b;
+  Ordering3.date = (a, b) => a.getTime() - b.getTime();
+  Ordering3.reverse = (ord) => (a, b) => ord(b, a);
+  Ordering3.thenBy = (ord2) => (ord1) => (a, b) => {
+    const r = ord1(a, b);
+    return r !== 0 ? r : ord2(a, b);
+  };
+  Ordering3.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
+  Ordering3.byFields = (orderings) => (a, b) => {
+    for (let i = 0; i < orderings.length; i++) {
+      const res = orderings[i](a, b);
+      if (res !== 0) {
+        return res;
+      }
+    }
+    return 0;
+  };
+  Ordering3.tuple = (...orderings) => (a, b) => {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+      const res = orderings[i](a[i], b[i]);
+      if (res !== 0) {
+        return res;
+      }
+    }
+    return a.length - b.length;
+  };
+})(Ordering || (Ordering = {}));
+
+// src/Core/Pair.ts
+var Pair;
+((Pair2) => {
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Pair2.from || (Pair2.from = {}));
+  Pair2.first = (p) => p[0];
+  Pair2.second = (p) => p[1];
+  Pair2.mapFirst = (f) => (p) => [f(p[0]), p[1]];
+  Pair2.mapSecond = (f) => (p) => [p[0], f(p[1])];
+  Pair2.mapBoth = (onFirst, onSecond) => (p) => [
+    onFirst(p[0]),
+    onSecond(p[1])
+  ];
+  Pair2.fold = (f) => (p) => f(p[0], p[1]);
+  Pair2.swap = (p) => [p[1], p[0]];
+  let to;
+  ((to2) => {
+    to2.Array = (p) => [...p];
+  })(to = Pair2.to || (Pair2.to = {}));
+  Pair2.tap = (f) => (p) => {
+    f(p[0], p[1]);
+    return p;
+  };
+})(Pair || (Pair = {}));
+
+// 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));
+  let from;
+  ((from2) => {
+    from2.Refinement = (r) => r;
+  })(from = Predicate2.from || (Predicate2.from = {}));
+  Predicate2.match = (branches, fallback) => (a) => {
+    for (let i = 0; i < branches.length; i++) {
+      const [p, h] = branches[i];
+      if (p(a)) {
+        return h(a);
+      }
+    }
+    return fallback(a);
+  };
+})(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);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+})(Reader || (Reader = {}));
+
+// src/Core/Refinement.ts
+var Refinement;
+((Refinement2) => {
+  let from;
+  ((from2) => {
+    from2.predicate = (f) => f;
+  })(from = Refinement2.from || (Refinement2.from = {}));
+  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);
+  let to;
+  ((to2) => {
+    to2.Maybe = (r) => (a) => r(a) ? Maybe.make.some(a) : Maybe.make.none();
+    to2.Result = (r, onFail) => (a) => r(a) ? Result.make.ok(a) : Result.make.err(onFail(a));
+  })(to = Refinement2.to || (Refinement2.to = {}));
+})(Refinement || (Refinement = {}));
+
+// src/Core/RemoteData.ts
+var _notAsked = { kind: "NotAsked" };
+var _loading = { kind: "Loading" };
+var RemoteData;
+((RemoteData2) => {
+  let make;
+  ((make2) => {
+    make2.notAsked = () => _notAsked;
+    make2.loading = () => _loading;
+    make2.failure = (error) => ({ kind: "Failure", error });
+    make2.success = (value) => ({ kind: "Success", value });
+  })(make = RemoteData2.make || (RemoteData2.make = {}));
+  let is;
+  ((is2) => {
+    is2.notAsked = (data) => data.kind === "NotAsked";
+    is2.loading = (data) => data.kind === "Loading";
+    is2.failure = (data) => data.kind === "Failure";
+    is2.success = (data) => data.kind === "Success";
+  })(is = RemoteData2.is || (RemoteData2.is = {}));
+  RemoteData2.map = (f) => (data) => is.success(data) ? make.success(f(data.value)) : data;
+  RemoteData2.mapError = (f) => (data) => is.failure(data) ? make.failure(f(data.error)) : data;
+  RemoteData2.chain = (f) => (data) => is.success(data) ? f(data.value) : data;
+  RemoteData2.ap = (arg) => (data) => {
+    if (is.success(data) && is.success(arg)) {
+      return make.success(data.value(arg.value));
+    }
+    if (is.failure(data)) {
+      return data;
+    }
+    if (is.failure(arg)) {
+      return arg;
+    }
+    if (is.loading(data) || is.loading(arg)) {
+      return make.loading();
+    }
+    return make.notAsked();
+  };
+  RemoteData2.fold = (onFailure, onNotAsked, onLoading, onSuccess) => (data) => {
+    switch (data.kind) {
+      case "Failure": {
+        return onFailure(data.error);
+      }
+      case "NotAsked": {
+        return onNotAsked();
+      }
+      case "Loading": {
+        return onLoading();
+      }
+      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) => is.success(data) ? data.value : defaultValue();
+  RemoteData2.tap = (f) => (data) => {
+    if (is.success(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  RemoteData2.tapError = (f) => (data) => {
+    if (is.failure(data)) {
+      f(data.error);
+    }
+    return data;
+  };
+  RemoteData2.recover = (fallback) => (data) => is.failure(data) ? fallback(data.error) : data;
+  let to;
+  ((to2) => {
+    to2.Maybe = (data) => is.success(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+    to2.Result = (onNotReady) => (data) => is.success(data) ? Result.make.ok(data.value) : Result.make.err(is.failure(data) ? data.error : onNotReady());
+  })(to = RemoteData2.to || (RemoteData2.to = {}));
+  let from;
+  ((from2) => {
+    from2.Result = (data) => Result.is.ok(data) ? make.success(data.value) : make.failure(data.error);
+    from2.Maybe = (onNone) => (data) => Maybe.is.some(data) ? make.success(data.value) : make.failure(onNone());
+  })(from = RemoteData2.from || (RemoteData2.from = {}));
+  RemoteData2.filter = (pred, onFalse) => (data) => is.success(data) ? pred(data.value) ? data : make.failure(onFalse(data.value)) : data;
+})(RemoteData || (RemoteData = {}));
+
+// src/Core/Resource.ts
+var Resource;
+((Resource2) => {
+  let from;
+  ((from2) => {
+    from2.handlers = (acquire, release) => ({
+      acquire,
+      release
+    });
+    from2.Task = (acquire, release) => ({
+      acquire: Task.map((a) => Result.make.ok(a))(acquire),
+      release
+    });
+  })(from = Resource2.from || (Resource2.from = {}));
+  Resource2.use = (f) => (resource) => (signal) => Deferred.from.Promise(
+    Deferred.to.Promise(resource.acquire(signal)).then(async (acquired) => {
+      if (Result.is.err(acquired)) {
+        return acquired;
+      }
+      const a = acquired.value;
+      try {
+        const usageResult = await Deferred.to.Promise(f(a)(signal));
+        return usageResult;
+      } finally {
+        await Deferred.to.Promise(resource.release(a)(signal));
+      }
+    })
+  );
+  Resource2.combine = (resourceA, resourceB) => ({
+    acquire: (signal) => Deferred.from.Promise(
+      Deferred.to.Promise(resourceA.acquire(signal)).then(async (acquiredA) => {
+        if (Result.is.err(acquiredA)) {
+          return acquiredA;
+        }
+        const a = acquiredA.value;
+        const acquiredB = await Deferred.to.Promise(resourceB.acquire(signal));
+        if (Result.is.err(acquiredB)) {
+          await Deferred.to.Promise(resourceA.release(a)(signal));
+          return acquiredB;
+        }
+        return Result.make.ok([a, acquiredB.value]);
+      })
+    ),
+    release: ([a, b]) => (signal) => Deferred.from.Promise(
+      Deferred.to.Promise(resourceB.release(b)(signal)).then(() => Deferred.to.Promise(resourceA.release(a)(signal)))
+    )
+  });
+})(Resource || (Resource = {}));
+
+// src/Core/Result.ts
+var Result;
+((Result4) => {
+  let make;
+  ((make2) => {
+    make2.ok = (value) => ({ kind: "Ok", value });
+    make2.err = (e) => ({ kind: "Err", error: e });
+  })(make = Result4.make || (Result4.make = {}));
+  let is;
+  ((is2) => {
+    is2.ok = (data) => data.kind === "Ok";
+    is2.err = (data) => data.kind === "Err";
+  })(is = Result4.is || (Result4.is = {}));
+  Result4.tryCatch = (f, options) => {
+    try {
+      return make.ok(f());
+    } catch (error) {
+      return make.err(options.onError(error));
+    }
+  };
+  Result4.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
+  Result4.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
+  Result4.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
+  Result4.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
+  Result4.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result4.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
+  Result4.tap = (f) => (data) => {
+    if (is.ok(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Result4.tapError = (f) => (data) => {
+    if (is.err(data)) {
+      f(data.error);
+    }
+    return data;
+  };
+  let from;
+  ((from2) => {
+    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.ok(a) : make.err(onFalse(a));
+    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.err(onNull()) : make.ok(value);
+    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.err(onNone()) : make.ok(maybe.value);
+    from2.Validation = (combineErrors) => (val) => Validation.is.passed(val) ? make.ok(val.value) : make.err(combineErrors(val.errors));
+  })(from = Result4.from || (Result4.from = {}));
+  Result4.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
+  Result4.recoverUnless = (isBlocked, fallback) => (data) => is.err(data) && !isBlocked(data.error) ? fallback() : data;
+  let to;
+  ((to2) => {
+    to2.Maybe = (data) => is.ok(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+    to2.Validation = (data) => Validation.from.Result(data);
+  })(to = Result4.to || (Result4.to = {}));
+  Result4.transposeMaybe = (data) => is.err(data) ? Maybe.make.some(data) : Maybe.is.some(data.value) ? Maybe.make.some(make.ok(data.value.value)) : Maybe.make.none();
+  Result4.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
+  Result4.bindTo = (key) => (data) => (0, Result4.map)((a) => ({ [key]: a }))(data);
+  Result4.bind = (key, f) => (data) => (0, Result4.chain)(
+    (a) => (0, Result4.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Result4.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if (is.err(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return make.ok(result);
+  };
+  Result4.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
+  Result4.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
+})(Result || (Result = {}));
+
+// 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];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  State2.focus = (lens) => (stateOp) => (s) => {
+    const subState = lens.get(s);
+    const [b, newSubState] = stateOp(subState);
+    return [b, lens.set(newSubState)(s)];
+  };
+})(State || (State = {}));
+
+// src/Core/Stream.ts
+var Stream;
+((Stream2) => {
+  Stream2.make = (options) => ({
+    options,
+    _listeners: /* @__PURE__ */ new Set(),
+    _queue: [],
+    _isEmitting: false
+  });
+  Stream2.emit = (target, message) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const msg = message;
+    for (const stream of targets) {
+      stream._queue.push(msg);
+      if (!stream._isEmitting) {
+        stream._isEmitting = true;
+        try {
+          while (stream._queue.length > 0) {
+            const nextMsg = stream._queue.shift();
+            const listeners = Array.from(stream._listeners);
+            for (const listener of listeners) {
+              try {
+                listener(nextMsg);
+              } catch (err2) {
+                if (stream.options?.onError) {
+                  stream.options.onError(err2);
+                } else {
+                  throw err2;
+                }
+              }
+            }
+          }
+        } finally {
+          stream._isEmitting = false;
+        }
+      }
+    }
+  };
+  Stream2.forward = (options) => {
+    const targets = Array.isArray(options.to) ? options.to : [options.to];
+    const filterSet = options.only ? new Set(options.only) : null;
+    const handler = (msg) => {
+      if (filterSet !== null && !filterSet.has(msg.kind)) {
+        return;
+      }
+      for (const target of targets) {
+        (0, Stream2.emit)(target, msg);
+      }
+    };
+    options.from._listeners.add(handler);
+    return () => {
+      options.from._listeners.delete(handler);
+    };
+  };
+  Stream2.listen = (stream, events, options) => {
+    const eventList = Array.isArray(events) ? events : [events];
+    const isOrdered = options?.ordered ?? false;
+    const isStrict = options?.strict ?? false;
+    const isOnce = options?.once ?? false;
+    const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+    const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+    const createMatcher = (onMatch) => {
+      let sequenceIndex = 0;
+      return (msg) => {
+        if (resetKinds !== null && resetKinds.has(msg.kind)) {
+          sequenceIndex = 0;
+          return;
+        }
+        if (!isOrdered) {
+          if (eventList.includes(msg.kind)) {
+            onMatch(msg);
+          }
+          return;
+        }
+        let expectedKind = eventList[sequenceIndex];
+        if (expectedKind !== msg.kind && optionalKinds !== null) {
+          let lookaheadIndex = sequenceIndex;
+          while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) {
+            lookaheadIndex++;
+          }
+          if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+            sequenceIndex = lookaheadIndex;
+            expectedKind = eventList[sequenceIndex];
+          }
+        }
+        if (msg.kind === expectedKind) {
+          sequenceIndex++;
+          if (sequenceIndex === eventList.length) {
+            sequenceIndex = 0;
+            onMatch(msg);
+          }
+        } else if (isStrict) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        } else if (eventList.includes(msg.kind)) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        }
+      };
+    };
+    return {
+      reduce: (reducer, initialState) => {
+        let currentState = initialState;
+        const listenerFn = createMatcher((msg) => {
+          currentState = reducer(msg, currentState);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return { unsubscribe, getState: () => currentState };
+      },
+      tap: (effect) => {
+        const listenerFn = createMatcher((msg) => {
+          effect(msg);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return unsubscribe;
+      }
+    };
+  };
+})(Stream || (Stream = {}));
+
+// src/Core/TaskMaybe.ts
+var TaskMaybe;
+((TaskMaybe2) => {
+  let make;
+  ((make2) => {
+    make2.some = (value) => Task.resolve(Maybe.make.some(value));
+    make2.none = () => Task.resolve(Maybe.make.none());
+  })(make = TaskMaybe2.make || (TaskMaybe2.make = {}));
+  ({ some: TaskMaybe2.some } = make);
+  ({ none: TaskMaybe2.none } = make);
+  let from;
+  ((from2) => {
+    from2.Maybe = (option) => Task.resolve(option);
+    from2.nullable = (value) => Task.resolve(Maybe.from.nullable(value));
+    from2.Result = (result) => Task.resolve(Result.to.Maybe(result));
+    from2.Task = (task) => Task.map(Maybe.make.some)(task);
+  })(from = TaskMaybe2.from || (TaskMaybe2.from = {}));
+  TaskMaybe2.tryCatch = (f) => (signal) => Deferred.from.Promise(Promise.resolve(f(signal)).then(Maybe.make.some).catch(() => Maybe.make.none()));
+  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
+  TaskMaybe2.chain = (f) => (data) => Task.chain(
+    (option) => Maybe.is.some(option) ? f(option.value) : Task.resolve(Maybe.make.none())
+  )(data);
+  TaskMaybe2.ap = (arg) => (data) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(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);
+  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
+  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
+  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
+  let to;
+  ((to2) => {
+    to2.Result = (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data);
+  })(to = TaskMaybe2.to || (TaskMaybe2.to = {}));
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskMaybe2.recover = (fallback) => (data) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.resolve(maybe))(
+    data
+  );
+  TaskMaybe2.struct = (fields) => (signal) => Deferred.from.Promise((() => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Maybe.is.none(res)) {
+          return res;
+        }
+        record[keys[i]] = res.value;
+      }
+      return Maybe.make.some(record);
+    });
+  })());
+  TaskMaybe2.memoize = (task) => Task.memoize(task);
+})(TaskMaybe || (TaskMaybe = {}));
+
+// src/Core/TaskResult.ts
+var TaskResult;
+((TaskResult2) => {
+  let make;
+  ((make2) => {
+    make2.ok = (value) => Task.resolve(Result.make.ok(value));
+    make2.err = (error) => Task.resolve(Result.make.err(error));
+  })(make = TaskResult2.make || (TaskResult2.make = {}));
+  ({ ok: TaskResult2.ok } = make);
+  ({ err: TaskResult2.err } = make);
+  let from;
+  ((from2) => {
+    from2.nullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.make.err(onNull()) : Result.make.ok(value));
+    from2.Maybe = (onNone) => (maybe) => Task.resolve(Maybe.is.none(maybe) ? Result.make.err(onNone()) : Result.make.ok(maybe.value));
+    from2.Result = (result) => Task.resolve(result);
+  })(from = TaskResult2.from || (TaskResult2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Maybe = (data) => Task.map(Result.to.Maybe)(data);
+  })(to = TaskResult2.to || (TaskResult2.to = {}));
+  TaskResult2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
+    globalThis.Promise.resolve().then(async () => f(signal)).then(Result.make.ok).catch(
+      (error) => Result.make.err(options.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.is.ok(result) ? f(result.value) : Task.resolve(Result.make.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.is.err(result) ? fallback(result.error) : Task.resolve(result)
+  )(data);
+  TaskResult2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (result) => Result.is.err(result) && !isBlocked(result.error) ? 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) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
+      ([of_, oa]) => Result.ap(oa)(of_)
+    )
+  );
+  TaskResult2.run = (signal) => (task) => task(signal);
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskResult2.struct = (fields) => (signal) => Deferred.from.Promise((() => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Result.is.err(res)) {
+          return res;
+        }
+        record[keys[i]] = res.value;
+      }
+      return Result.make.ok(record);
+    });
+  })());
+  TaskResult2.retry = (policy) => (task) => (signal) => Deferred.from.Promise((() => {
+    const { attempts } = policy;
+    const wait = (duration) => new Promise((res) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        res();
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return res();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        res();
+      }, Duration.to.milliseconds(duration));
+    });
+    const executeAttempt = (attempt) => Deferred.to.Promise(task(signal)).then((res) => {
+      if (Result.is.ok(res) || attempt >= attempts || signal?.aborted) {
+        return res;
+      }
+      const delay = policy.getDelay(attempt);
+      return wait(delay).then(() => executeAttempt(attempt + 1));
+    });
+    return executeAttempt(1);
+  })());
+  TaskResult2.memoize = (task) => Task.memoize(task);
+  TaskResult2.timeout = (options) => (task) => (signal) => Deferred.from.Promise(
+    new Promise((resolve) => {
+      const ms = Duration.to.milliseconds(options.duration);
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return Deferred.to.Promise(task(signal)).then(resolve);
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(Result.make.err(options.onTimeout()));
+      }, ms);
+      Deferred.to.Promise(task(signal)).then((res) => {
+        clearTimeout(timerId);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(res);
+      });
+    })
+  );
+  TaskResult2.allSettled = (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))));
+})(TaskResult || (TaskResult = {}));
+
+// src/internal/InternalTypes.ts
+var isNonEmptyArr = (list) => list.length > 0;
+
+// src/Core/TaskValidation.ts
+var TaskValidation;
+((TaskValidation2) => {
+  let make;
+  ((make2) => {
+    make2.passed = (value) => Task.resolve(Validation.make.passed(value));
+    make2.failed = (error) => Task.resolve(Validation.make.failed(error));
+    make2.failedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
+  })(make = TaskValidation2.make || (TaskValidation2.make = {}));
+  ({ passed: TaskValidation2.passed } = make);
+  ({ failed: TaskValidation2.failed } = make);
+  ({ failedAll: TaskValidation2.failedAll } = make);
+  let from;
+  ((from2) => {
+    from2.Validation = (validation) => Task.resolve(validation);
+    from2.nullable = (onNull) => (value) => Task.resolve(
+      value === null || value === void 0 ? Validation.make.failed(onNull()) : Validation.make.passed(value)
+    );
+    from2.Maybe = (onNone) => (maybe) => Task.resolve(
+      Maybe.is.none(maybe) ? Validation.make.failed(onNone()) : Validation.make.passed(maybe.value)
+    );
+    from2.Result = (result) => Task.resolve(Validation.from.Result(result));
+  })(from = TaskValidation2.from || (TaskValidation2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Result = (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data);
+    to2.Maybe = (data) => Task.map(Validation.to.Maybe)(data);
+  })(to = TaskValidation2.to || (TaskValidation2.to = {}));
+  TaskValidation2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
+    globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
+      (error) => Validation.make.failed(options.onError(error))
+    )
+  );
+  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
+  TaskValidation2.ap = (arg) => (data) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
+      ([vf, va]) => Validation.ap(va)(vf)
+    )
+  );
+  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.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
+  TaskValidation2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
+  TaskValidation2.product = (first, second) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
+      ([va, vb]) => Validation.product(va, vb)
+    )
+  );
+  TaskValidation2.productAll = (data) => (signal) => Deferred.from.Promise(
+    Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
+      const [first, ...rest] = results;
+      return Validation.productAll([first, ...rest]);
+    })
+  );
+  TaskValidation2.mapError = (f) => (data) => Task.map(Validation.mapError(f))(data);
+  TaskValidation2.tapError = (f) => (data) => Task.map(Validation.tapError(f))(data);
+  TaskValidation2.struct = (fields) => (signal) => Deferred.from.Promise((() => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      const errors = [];
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Validation.is.passed(res)) {
+          record[keys[i]] = res.value;
+        } else {
+          errors.push(...res.errors);
+        }
+      }
+      return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
+    });
+  })());
+  TaskValidation2.memoize = (task) => Task.memoize(task);
+})(TaskValidation || (TaskValidation = {}));
+
+// src/Core/Task.ts
+var toPromise = (task, signal) => Deferred.to.Promise(task(signal));
+var fromPromise = (f) => (signal) => Deferred.from.Promise(f(signal));
+var getMs2 = (duration) => Duration.to.milliseconds(duration);
+var Task;
+((Task2) => {
+  Task2.resolve = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
+  let from;
+  ((from2) => {
+    from2.sync = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
+  })(from = Task2.from || (Task2.from = {}));
+  Task2.tryCatch = (f, options) => fromPromise((signal) => globalThis.Promise.resolve().then(() => f(signal)).catch((err2) => options.onError(err2)));
+  Task2.map = (f) => (data) => fromPromise((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => fromPromise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
+  Task2.ap = (arg) => (data) => fromPromise((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
+  Task2.tap = (f) => (data) => fromPromise(
+    (signal) => toPromise(data, signal).then((a) => {
+      f(a);
+      return a;
+    })
+  );
+  Task2.all = (tasks) => fromPromise(
+    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
+  );
+  Task2.delay = (duration) => (data) => fromPromise(
+    (signal) => new Promise((res) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        res(toPromise(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return res(toPromise(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        res(toPromise(data, signal));
+      }, getMs2(duration));
+    })
+  );
+  Task2.repeat = (options) => (task) => fromPromise((signal) => {
+    const { times, delay: delayDuration } = options;
+    if (times <= 0) {
+      return Promise.resolve([]);
+    }
+    const results = [];
+    const wait = () => new Promise((r) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        r();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        r();
+      }, delayDuration ? getMs2(delayDuration) : 0);
+    });
+    const run2 = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) {
+          return results;
+        }
+        return wait().then(() => run2(left - 1));
+      });
+    };
+    return run2(times);
+  });
+  Task2.repeatUntil = (options) => (task) => fromPromise((signal) => {
+    const { when: predicate, delay: delayDuration, maxAttempts } = options;
+    const wait = () => new Promise((r) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        r();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        r();
+      }, delayDuration ? getMs2(delayDuration) : 0);
+    });
+    const run2 = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        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;
+        }
+        return wait().then(() => run2(attempt + 1, a));
+      });
+    };
+    return run2(1);
+  });
+  Task2.race = (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.from.Promise(new Promise(() => {
+      }));
+    }
+    return fromPromise((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) => fromPromise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
+  Task2.sequential = (tasks) => fromPromise(async (signal) => {
+    const results = [];
+    for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
+      results.push(await toPromise(task, signal));
+    }
+    return results;
+  });
+  Task2.timeout = (options) => (task) => fromPromise((outerSignal) => {
+    const { duration, onTimeout } = options;
+    const controller = new AbortController();
+    let timerId;
+    let cleanUp = () => {
+    };
+    const onOuterAbort = () => {
+      cleanUp();
+      controller.abort();
+    };
+    cleanUp = () => {
+      clearTimeout(timerId);
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
+    return Promise.race([
+      toPromise(task, controller.signal).then((a) => {
+        cleanUp();
+        return Result.make.ok(a);
+      }),
+      new Promise((res) => {
+        timerId = setTimeout(() => {
+          controller.abort();
+          cleanUp();
+          res(Result.make.err(onTimeout()));
+        }, getMs2(duration));
+      })
+    ]);
+  });
+  Task2.abortable = (factory) => {
+    let currentController = null;
+    const abort = () => currentController?.abort();
+    const task = (outerSignal) => {
+      currentController?.abort();
+      currentController = new AbortController();
+      const controller = currentController;
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.from.Promise(factory(controller.signal));
+    };
+    return { task, abort };
+  };
+  Task2.run = (signal) => (task) => task(signal);
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Task2.memoize = (task) => {
+    let cached = null;
+    return (signal) => {
+      if (cached === null) {
+        cached = task(signal);
+      }
+      return cached;
+    };
+  };
+  Task2.withProgress = (onProgress) => (task) => (signal) => {
+    onProgress(0);
+    const d = task(signal);
+    return Deferred.from.Promise(
+      Deferred.to.Promise(d).then((res) => {
+        onProgress(1);
+        return res;
+      })
+    );
+  };
+  Task2.withLabel = (label) => (task) => {
+    const fn = ((signal) => task(signal));
+    Object.defineProperty(fn, "label", { value: label, writable: false, enumerable: true, configurable: true });
+    return fn;
+  };
+  Task2.Maybe = TaskMaybe;
+  Task2.Result = TaskResult;
+  Task2.Validation = TaskValidation;
+})(Task || (Task = {}));
+
+// src/Core/These.ts
+var These;
+((These2) => {
+  let make;
+  ((make2) => {
+    make2.first = (value) => ({ kind: "First", first: value });
+    make2.second = (value) => ({ kind: "Second", second: value });
+    make2.both = (f, s) => ({ kind: "Both", first: f, second: s });
+  })(make = These2.make || (These2.make = {}));
+  let is;
+  ((is2) => {
+    is2.first = (data) => data.kind === "First";
+    is2.second = (data) => data.kind === "Second";
+    is2.both = (data) => data.kind === "Both";
+  })(is = These2.is || (These2.is = {}));
+  These2.hasFirst = (data) => data.kind === "First" || data.kind === "Both";
+  These2.hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
+  These2.mapFirst = (f) => (data) => {
+    if (is.second(data)) {
+      return data;
+    }
+    if (is.first(data)) {
+      return make.first(f(data.first));
+    }
+    return make.both(f(data.first), data.second);
+  };
+  These2.mapSecond = (f) => (data) => {
+    if (is.first(data)) {
+      return data;
+    }
+    if (is.second(data)) {
+      return make.second(f(data.second));
+    }
+    return make.both(data.first, f(data.second));
+  };
+  These2.mapBoth = (onFirst, onSecond) => (data) => {
+    if (is.second(data)) {
+      return make.second(onSecond(data.second));
+    }
+    if (is.first(data)) {
+      return make.first(onFirst(data.first));
+    }
+    return make.both(onFirst(data.first), onSecond(data.second));
+  };
+  These2.chainFirst = (f) => (data) => {
+    if (is.second(data)) {
+      return data;
+    }
+    return f(data.first);
+  };
+  These2.chainSecond = (f) => (data) => {
+    if (is.first(data)) {
+      return data;
+    }
+    return f(data.second);
+  };
+  These2.fold = (onFirst, onSecond, onBoth) => (data) => {
+    if (is.second(data)) {
+      return onSecond(data.second);
+    }
+    if (is.first(data)) {
+      return onFirst(data.first);
+    }
+    return onBoth(data.first, data.second);
+  };
+  These2.match = (cases) => (data) => {
+    if (is.second(data)) {
+      return cases.second(data.second);
+    }
+    if (is.first(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 (is.second(data)) {
+      return make.first(data.second);
+    }
+    if (is.first(data)) {
+      return make.second(data.first);
+    }
+    return make.both(data.second, data.first);
+  };
+})(These || (These = {}));
+
+// src/Core/Validation.ts
+var Validation;
+((Validation2) => {
+  let make;
+  ((make2) => {
+    make2.passed = (value) => ({ kind: "Passed", value });
+    make2.failed = (error) => ({ kind: "Failed", errors: [error] });
+    make2.failedAll = (errors) => ({ kind: "Failed", errors });
+  })(make = Validation2.make || (Validation2.make = {}));
+  let is;
+  ((is2) => {
+    is2.passed = (data) => data.kind === "Passed";
+    is2.failed = (data) => data.kind === "Failed";
+  })(is = Validation2.is || (Validation2.is = {}));
+  Validation2.tryCatch = (f, options) => {
+    try {
+      return make.passed(f());
+    } catch (error) {
+      return make.failed(options.onError(error));
+    }
+  };
+  let from;
+  ((from2) => {
+    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.passed(a) : make.failed(onFalse(a));
+    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.failed(onNull()) : make.passed(value);
+    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.failed(onNone()) : make.passed(maybe.value);
+    from2.Result = (data) => data.kind === "Ok" ? make.passed(data.value) : make.failed(data.error);
+  })(from = Validation2.from || (Validation2.from = {}));
+  Validation2.map = (f) => (data) => is.passed(data) ? make.passed(f(data.value)) : data;
+  Validation2.mapError = (f) => (data) => is.failed(data) ? make.failedAll(data.errors.map(f)) : data;
+  Validation2.ap = (arg) => (data) => {
+    if (is.passed(data)) {
+      return is.passed(arg) ? make.passed(data.value(arg.value)) : make.failedAll(arg.errors);
+    }
+    return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll([...data.errors, ...arg.errors]);
+  };
+  Validation2.apCustom = (concat) => (arg) => (data) => {
+    if (is.passed(data)) {
+      return is.passed(arg) ? make.passed(data.value(arg.value)) : make.failedAll(arg.errors);
+    }
+    return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll(concat(data.errors, arg.errors));
+  };
+  Validation2.fold = (onFailed, onPassed) => (data) => is.passed(data) ? onPassed(data.value) : onFailed(data.errors);
+  Validation2.match = (cases) => (data) => is.passed(data) ? cases.passed(data.value) : cases.failed(data.errors);
+  Validation2.getOrElse = (defaultValue) => (data) => is.passed(data) ? data.value : defaultValue();
+  Validation2.tap = (f) => (data) => {
+    if (is.passed(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Validation2.tapError = (f) => (data) => {
+    if (is.failed(data)) {
+      f(data.errors);
+    }
+    return data;
+  };
+  Validation2.recover = (fallback) => (data) => is.passed(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => is.failed(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  let to;
+  ((to2) => {
+    function Result4(arg) {
+      if (typeof arg === "function") {
+        const combine = arg;
+        return (val) => is.passed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
+      }
+      return is.passed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
+    }
+    to2.Result = Result4;
+    to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+  })(to = Validation2.to || (Validation2.to = {}));
+  Validation2.product = (first, second) => {
+    if (is.passed(first)) {
+      return is.passed(second) ? make.passed([first.value, second.value]) : make.failedAll(second.errors);
+    }
+    return is.passed(second) ? make.failedAll(first.errors) : make.failedAll([...first.errors, ...second.errors]);
+  };
+  Validation2.productAll = (data) => {
+    const values = [];
+    const errors = [];
+    for (const v of data) {
+      if (is.passed(v)) {
+        values.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
+    }
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(values);
+  };
+  Validation2.struct = (fields) => {
+    const record = {};
+    const errors = [];
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const val = fields[key];
+        if (is.passed(val)) {
+          record[key] = val.value;
+        } else {
+          errors.push(...val.errors);
+        }
+      }
+    }
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
+  };
+})(Validation || (Validation = {}));
+
+// src/Data/Arr.ts
+var ArrMaybe;
+((ArrMaybe2) => {
+  ArrMaybe2.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 Maybe.make.none();
+      }
+      result[i] = mapped.value;
+    }
+    return Maybe.make.some(result);
+  };
+  ArrMaybe2.sequence = (data) => (0, ArrMaybe2.traverse)((a) => a)(data);
+})(ArrMaybe || (ArrMaybe = {}));
+var ArrResult;
+((ArrResult2) => {
+  ArrResult2.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 === "Err") {
+        return mapped;
+      }
+      result[i] = mapped.value;
+    }
+    return Result.make.ok(result);
+  };
+  ArrResult2.sequence = (data) => (0, ArrResult2.traverse)((a) => a)(data);
+})(ArrResult || (ArrResult = {}));
+var ArrTaskResult;
+((ArrTaskResult2) => {
+  ArrTaskResult2.traverse = (f) => (data) => () => Deferred.from.Promise((async () => {
+    const result = [];
+    for (const a of data) {
+      const r = await Deferred.to.Promise(f(a)());
+      if (Result.is.err(r)) {
+        return r;
+      }
+      result.push(r.value);
+    }
+    return Result.make.ok(result);
+  })());
+  ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
+})(ArrTaskResult || (ArrTaskResult = {}));
+var ArrTask;
+((ArrTask2) => {
+  ArrTask2.traverse = (f) => (data) => () => Deferred.from.Promise(Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
+  ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
+  ArrTask2.Result = ArrTaskResult;
+})(ArrTask || (ArrTask = {}));
+var ArrNonEmpty;
+((ArrNonEmpty2) => {
+  ArrNonEmpty2.singleton = (value) => [value];
+  let from;
+  ((from2) => {
+    from2.Array = (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none();
+  })(from = ArrNonEmpty2.from || (ArrNonEmpty2.from = {}));
+  ArrNonEmpty2.head = (data) => data[0];
+  ArrNonEmpty2.last = (data) => data[data.length - 1];
+  ArrNonEmpty2.tail = (data) => data.slice(1);
+  ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
+  ArrNonEmpty2.map = (f) => (data) => Arr.map(f)(data);
+  ArrNonEmpty2.mapWithIndex = (f) => (data) => Arr.mapWithIndex(f)(data);
+  ArrNonEmpty2.intersperse = (sep) => (data) => Arr.intersperse(sep)(data);
+  ArrNonEmpty2.concat = (other) => (data) => Arr.concat(other)(data);
+  ArrNonEmpty2.reverse = (data) => Arr.reverse(data);
+})(ArrNonEmpty || (ArrNonEmpty = {}));
+var Arr;
+((Arr2) => {
+  Arr2.head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
+  Arr2.last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
+  Arr2.tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
+  Arr2.init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
+  Arr2.findFirst = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
+  };
+  Arr2.findLast = (predicate) => (data) => {
+    for (let i = data.length - 1; i >= 0; i--) {
+      if (predicate(data[i])) {
+        return Maybe.make.some(data[i]);
+      }
+    }
+    return Maybe.make.none();
+  };
+  Arr2.findIndex = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.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.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]);
+    }
+    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.filterMap = (f) => (data) => {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Some") {
+        result.push(mapped.value);
+      }
+    }
+    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.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] = [];
+      }
+      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.uniqWith = (eq) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!result.some((x) => eq(x, a))) {
+        result.push(a);
+      }
+    }
+    return result;
+  };
+  Arr2.sortBy = (compare) => (data) => {
+    const arr = data;
+    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);
+    }
+    return [...data].sort(ord);
+  };
+  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.concat = (other) => (data) => [...data, ...other];
+  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) => {
+    let totalLen = 0;
+    const outerLen = data.length;
+    for (let i = 0; i < outerLen; i++) {
+      totalLen += data[i].length;
+    }
+    const result = new Array(totalLen);
+    let idx = 0;
+    for (let i = 0; i < outerLen; i++) {
+      const chunk = data[i];
+      const innerLen = chunk.length;
+      for (let j = 0; j < innerLen; j++) {
+        result[idx++] = chunk[j];
+      }
+    }
+    return result;
+  };
+  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);
+  const _traverseTask = Object.assign((f) => ArrTask.traverse(f), {
+    Result: ArrTaskResult.traverse
+  });
+  const _sequenceTask = Object.assign((data) => ArrTask.sequence(data), {
+    Result: ArrTaskResult.sequence
+  });
+  let traverse;
+  ((traverse2) => {
+    traverse2.Maybe = ArrMaybe.traverse;
+    traverse2.Result = ArrResult.traverse;
+    traverse2.Task = _traverseTask;
+  })(traverse = Arr2.traverse || (Arr2.traverse = {}));
+  let sequence;
+  ((sequence2) => {
+    sequence2.Maybe = ArrMaybe.sequence;
+    sequence2.Result = ArrResult.sequence;
+    sequence2.Task = _sequenceTask;
+  })(sequence = Arr2.sequence || (Arr2.sequence = {}));
+  let is;
+  ((is2) => {
+    is2.empty = (data) => data.length === 0;
+    is2.nonEmpty = (data) => isNonEmptyArr(data);
+  })(is = Arr2.is || (Arr2.is = {}));
+  Arr2.prepend = (value) => (data) => [value, ...data];
+  Arr2.append = (value) => (data) => [...data, value];
+  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].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);
+    }
+    const result = [...data];
+    result.splice(i, 0, item);
+    return result;
+  };
+  Arr2.removeAt = (index) => (data) => {
+    if (index < 0 || index >= data.length) {
+      return data;
+    }
+    const arr = data;
+    if (typeof arr.toSpliced === "function") {
+      return arr.toSpliced(index, 1);
+    }
+    const result = [...data];
+    result.splice(index, 1);
+    return result;
+  };
+  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)];
+  };
+  Arr2.partitionMaybe = (f) => (data) => {
+    const failures = [];
+    const successes = [];
+    for (let i = 0; i < data.length; i++) {
+      const res = f(data[i]);
+      if (res.kind === "Some") {
+        successes.push(res.value);
+      } else {
+        failures.push(data[i]);
+      }
+    }
+    return [failures, successes];
+  };
+  Arr2.at = (index) => (data) => {
+    const targetIndex = index < 0 ? data.length + index : index;
+    if (targetIndex < 0 || targetIndex >= data.length) {
+      return Maybe.make.none();
+    }
+    return Maybe.make.some(data[targetIndex]);
+  };
+  Arr2.findMap = (f) => (data) => {
+    for (let i = 0; i < data.length; i++) {
+      const res = f(data[i]);
+      if (res.kind === "Some") {
+        return res;
+      }
+    }
+    return Maybe.make.none();
+  };
+  Arr2.indexBy = (keyFn) => (data) => {
+    const map2 = new globalThis.Map();
+    for (let i = 0; i < data.length; i++) {
+      map2.set(keyFn(data[i]), data[i]);
+    }
+    return map2;
+  };
+  Arr2.frequencies = (data) => {
+    const map2 = new globalThis.Map();
+    for (let i = 0; i < data.length; i++) {
+      const item = data[i];
+      map2.set(item, (map2.get(item) ?? 0) + 1);
+    }
+    return map2;
+  };
+  Arr2.chunkBy = (keyFn) => (data) => {
+    if (data.length === 0) {
+      return [];
+    }
+    const result = [];
+    let currentChunk = [data[0]];
+    let currentKey = keyFn(data[0]);
+    for (let i = 1; i < data.length; i++) {
+      const item = data[i];
+      const key = keyFn(item);
+      if (Object.is(key, currentKey)) {
+        currentChunk.push(item);
+      } else {
+        result.push(currentChunk);
+        currentChunk = [item];
+        currentKey = key;
+      }
+    }
+    result.push(currentChunk);
+    return result;
+  };
+  Arr2.dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
+    if (data.length === 0) {
+      return [];
+    }
+    const result = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      if (!eq(data[i], result[result.length - 1])) {
+        result.push(data[i]);
+      }
+    }
+    return result;
+  };
+  Arr2.windowed = (size2, options) => (data) => {
+    const step = options?.step ?? 1;
+    if (size2 <= 0 || step <= 0 || data.length < size2) {
+      return [];
+    }
+    const result = [];
+    for (let i = 0; i <= data.length - size2; i += step) {
+      result.push(data.slice(i, i + size2));
+    }
+    return result;
+  };
+  Arr2.unfold = (initial, f) => {
+    const result = [];
+    let currentState = initial;
+    while (true) {
+      const next = f(currentState);
+      if (next.kind === "None") {
+        break;
+      }
+      const [item, nextState] = next.value;
+      result.push(item);
+      currentState = nextState;
+    }
+    return result;
+  };
+  Arr2.NonEmpty = ArrNonEmpty;
+})(Arr || (Arr = {}));
+
+// src/Data/BigNum.ts
+var BigNum;
+((BigNum2) => {
+  let from;
+  ((from2) => {
+    from2.string = (s) => {
+      try {
+        if (s.trim() === "") {
+          return Maybe.make.none();
+        }
+        return Maybe.make.some(BigInt(s));
+      } catch {
+        return Maybe.make.none();
+      }
+    };
+    from2.number = (n) => {
+      if (!Number.isInteger(n) || n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
+        return Maybe.make.none();
+      }
+      return Maybe.make.some(BigInt(n));
+    };
+  })(from = BigNum2.from || (BigNum2.from = {}));
+  let to;
+  ((to2) => {
+    to2.number = (b) => {
+      if (b < BigInt(Number.MIN_SAFE_INTEGER) || b > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Maybe.make.none();
+      }
+      return Maybe.make.some(Number(b));
+    };
+  })(to = BigNum2.to || (BigNum2.to = {}));
+  BigNum2.add = (b) => (a) => a + b;
+  BigNum2.sub = (b) => (a) => a - b;
+  BigNum2.mul = (b) => (a) => a * b;
+  BigNum2.div = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a / b);
+  BigNum2.mod = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a % b);
+  BigNum2.clamp = (min2, max2) => (a) => a < min2 ? min2 : a > max2 ? max2 : a;
+  BigNum2.inRange = (start, end) => (a) => a >= start && a < end;
+  BigNum2.abs = (a) => a < 0n ? -a : a;
+  BigNum2.min = (b) => (a) => a < b ? a : b;
+  BigNum2.max = (b) => (a) => a > b ? a : b;
+})(BigNum || (BigNum = {}));
+
+// src/Data/Dict.ts
+var DictNonEmpty;
+((DictNonEmpty2) => {
+  DictNonEmpty2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  let from;
+  ((from2) => {
+    from2.Map = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
+  })(from = DictNonEmpty2.from || (DictNonEmpty2.from = {}));
+  DictNonEmpty2.keys = (m) => Dict.keys(m);
+  DictNonEmpty2.values = (m) => Dict.values(m);
+  DictNonEmpty2.entries = (m) => Dict.entries(m);
+  DictNonEmpty2.reduce = (f) => (m) => (0, DictNonEmpty2.values)(m).reduce(f);
+  DictNonEmpty2.map = (f) => (m) => Dict.map(f)(m);
+  DictNonEmpty2.mapWithKey = (f) => (m) => Dict.mapWithKey(f)(m);
+})(DictNonEmpty || (DictNonEmpty = {}));
+var Dict;
+((Dict2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (m) => m.size === 0;
+    is2.nonEmpty = (m) => m.size > 0;
+  })(is = Dict2.is || (Dict2.is = {}));
+  Dict2.empty = () => new globalThis.Map();
+  Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  let from;
+  ((from2) => {
+    from2.entries = (entries3) => new globalThis.Map(entries3);
+    from2.Record = (rec) => new globalThis.Map(Object.entries(rec));
+  })(from = Dict2.from || (Dict2.from = {}));
+  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) ? Maybe.make.some(m.get(key)) : Maybe.make.none();
+  Dict2.size = (m) => m.size;
+  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.filterMap = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [key, value] of m) {
+      const mapped = f(value);
+      if (mapped.kind === "Some") {
+        result.set(key, mapped.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;
+  };
+  function mergeWith(combine) {
+    return (arg1, arg2) => {
+      if (arg2 !== void 0) {
+        const first = arg1;
+        const second2 = arg2;
+        const res = new globalThis.Map(first);
+        for (const [k, v] of second2) {
+          if (res.has(k)) {
+            res.set(k, combine(res.get(k), v));
+          } else {
+            res.set(k, v);
+          }
+        }
+        return res;
+      }
+      const second = arg1;
+      return (first) => {
+        const res = new globalThis.Map(first);
+        for (const [k, v] of second) {
+          if (res.has(k)) {
+            res.set(k, combine(res.get(k), v));
+          } else {
+            res.set(k, v);
+          }
+        }
+        return res;
+      };
+    };
+  }
+  Dict2.mergeWith = mergeWith;
+  let to;
+  ((to2) => {
+    to2.Record = (m) => Object.fromEntries(m);
+  })(to = Dict2.to || (Dict2.to = {}));
+  Dict2.mapEntries = (f) => (data) => {
+    const res = new globalThis.Map();
+    for (const [k, v] of data) {
+      const [nk, nv] = f(k, v);
+      res.set(nk, nv);
+    }
+    return res;
+  };
+  Dict2.mapKeys = (f) => (data) => {
+    const res = new globalThis.Map();
+    for (const [k, v] of data) {
+      res.set(f(k), v);
+    }
+    return res;
+  };
+  Dict2.NonEmpty = DictNonEmpty;
+})(Dict || (Dict = {}));
+
+// src/Data/Json.ts
+var isSyntaxError = (err2) => typeof err2 === "object" && err2 !== null && "name" in err2 && err2.name === "SyntaxError";
+var isTypeError = (err2) => typeof err2 === "object" && err2 !== null && "name" in err2 && err2.name === "TypeError";
+var Json;
+((Json2) => {
+  Json2.parse = (text) => Result.tryCatch(() => JSON.parse(text), {
+    onError: (err2) => isSyntaxError(err2) ? err2 : new SyntaxError(String(err2))
+  });
+  Json2.stringify = (value, replacer, space) => Result.tryCatch(() => JSON.stringify(value, replacer, space), {
+    onError: (err2) => isTypeError(err2) ? err2 : new TypeError(String(err2))
+  });
+})(Json || (Json = {}));
+
+// src/Data/Num.ts
+var Num;
+((Num2) => {
+  let is;
+  ((is2) => {
+    is2.zero = (n) => n === 0;
+    is2.integer = (n) => Number.isInteger(n);
+    is2.float = (n) => Number.isFinite(n) && !Number.isInteger(n);
+    is2.finite = (n) => Number.isFinite(n);
+    is2.nan = (n) => Number.isNaN(n);
+    is2.even = (n) => Number.isInteger(n) && n % 2 === 0;
+    is2.odd = (n) => Number.isInteger(n) && n % 2 !== 0;
+    is2.positive = (n) => n > 0;
+    is2.negative = (n) => n < 0;
+  })(is = Num2.is || (Num2.is = {}));
+  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 = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
+  Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
+  Num2.inRange = (start, end) => (n) => n >= start && n < end;
+  Num2.parse = (s) => {
+    if (s.trim() === "") {
+      return Maybe.make.none();
+    }
+    const n = Number(s);
+    return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
+  };
+  Num2.add = (b) => (a) => a + b;
+  Num2.subtract = (b) => (a) => a - b;
+  Num2.multiply = (b) => (a) => a * b;
+  Num2.divide = (b) => (a) => b === 0 ? Maybe.make.none() : Maybe.make.some(a / b);
+  Num2.abs = (n) => Math.abs(n);
+  Num2.negate = (n) => -n;
+  Num2.round = (n) => Math.round(n);
+  Num2.floor = (n) => Math.floor(n);
+  Num2.ceil = (n) => Math.ceil(n);
+  Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(n % divisor);
+  Num2.sum = (ns) => {
+    let result = 0;
+    for (let i = 0; i < ns.length; i++) {
+      result += ns[i];
+    }
+    return result;
+  };
+  Num2.mean = (ns) => ns.length === 0 ? Maybe.make.none() : Maybe.make.some((0, Num2.sum)(ns) / ns.length);
+  Num2.min = (ns) => {
+    if (ns.length === 0) {
+      return Maybe.make.none();
+    }
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] < result) {
+        result = ns[i];
+      }
+    }
+    return Maybe.make.some(result);
+  };
+  Num2.max = (ns) => {
+    if (ns.length === 0) {
+      return Maybe.make.none();
+    }
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] > result) {
+        result = ns[i];
+      }
+    }
+    return Maybe.make.some(result);
+  };
+  Num2.format = (options, locales) => (n) => !Number.isFinite(n) ? Maybe.make.none() : Maybe.make.some(new Intl.NumberFormat(locales, options).format(n));
+})(Num || (Num = {}));
+
+// src/Data/Rec.ts
+var _isNonEmpty = (data) => Object.keys(data).length > 0;
+var RecMaybe;
+((RecMaybe2) => {
+  RecMaybe2.traverse = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const result = {};
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      const maybeVal = f(data[key]);
+      if (maybeVal.kind === "None") {
+        return maybeVal;
+      }
+      Object.defineProperty(result, key, { value: maybeVal.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "Some", value: result };
+  };
+  RecMaybe2.sequence = (data) => (0, RecMaybe2.traverse)((a) => a)(data);
+})(RecMaybe || (RecMaybe = {}));
+var RecResult;
+((RecResult2) => {
+  RecResult2.traverse = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const result = {};
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      const res = f(data[key]);
+      if (res.kind === "Err") {
+        return res;
+      }
+      Object.defineProperty(result, key, { value: res.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "Ok", value: result };
+  };
+  RecResult2.sequence = (data) => (0, RecResult2.traverse)((a) => a)(data);
+})(RecResult || (RecResult = {}));
+var RecNonEmpty;
+((RecNonEmpty2) => {
+  RecNonEmpty2.singleton = (key, value) => ({ [key]: value });
+  let from;
+  ((from2) => {
+    from2.Record = (data) => _isNonEmpty(data) ? Maybe.make.some(data) : Maybe.make.none();
+  })(from = RecNonEmpty2.from || (RecNonEmpty2.from = {}));
+  RecNonEmpty2.keys = (data) => Rec.keys(data);
+  RecNonEmpty2.values = (data) => Rec.values(data);
+  RecNonEmpty2.entries = (data) => Rec.entries(data);
+  RecNonEmpty2.reduce = (f) => (data) => (0, RecNonEmpty2.values)(data).reduce(f);
+  RecNonEmpty2.map = (f) => (data) => Rec.map(f)(data);
+  RecNonEmpty2.mapWithKey = (f) => (data) => Rec.mapWithKey(f)(data);
+})(RecNonEmpty || (RecNonEmpty = {}));
+var Rec;
+((Rec2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (data) => Object.keys(data).length === 0;
+    is2.nonEmpty = _isNonEmpty;
+  })(is = Rec2.is || (Rec2.is = {}));
+  Rec2.map = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
+    const result = Object.create(Object.getPrototypeOf(data));
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      if (key === "__proto__") {
+        Object.defineProperty(result, "__proto__", {
+          value: f(recordValues[i]),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        result[key] = f(recordValues[i]);
+      }
+    }
+    return result;
+  };
+  Rec2.filterMap = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
+    const result = Object.create(Object.getPrototypeOf(data));
+    for (let i = 0; i < recordKeys.length; i++) {
+      const maybeVal = f(recordValues[i]);
+      if (maybeVal.kind === "Some") {
+        Object.defineProperty(result, recordKeys[i], {
+          value: maybeVal.value,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return result;
+  };
+  Rec2.mapWithKey = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
+    const result = Object.create(Object.getPrototypeOf(data));
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      if (key === "__proto__") {
+        Object.defineProperty(result, "__proto__", {
+          value: f(key, recordValues[i]),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        result[key] = f(key, recordValues[i]);
+      }
+    }
+    return result;
+  };
+  Rec2.filter = (predicate) => (data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
+    const result = Object.create(Object.getPrototypeOf(data));
+    for (let i = 0; i < recordKeys.length; i++) {
+      if (predicate(recordValues[i])) {
+        Object.defineProperty(result, recordKeys[i], {
+          value: recordValues[i],
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return result;
+  };
+  Rec2.filterWithKey = (predicate) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (predicate(k, v)) {
+        Object.defineProperty(result, k, { value: v, writable: true, enumerable: true, configurable: true });
+      }
+    }
+    return result;
+  };
+  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? { kind: "Some", value: data[key] } : { kind: "None" };
+  Rec2.keys = (data) => Object.keys(data);
+  Rec2.values = (data) => Object.values(data);
+  Rec2.entries = (data) => Object.entries(data);
+  let from;
+  ((from2) => {
+    from2.entries = (data) => Object.fromEntries(data);
+  })(from = Rec2.from || (Rec2.from = {}));
+  Rec2.groupBy = (keyFn) => (items) => {
+    const result = {};
+    for (const item of items) {
+      const key = keyFn(item);
+      if (Object.hasOwn(result, key)) {
+        result[key].push(item);
+      } else {
+        Object.defineProperty(result, key, { value: [item], writable: true, enumerable: true, configurable: true });
+      }
+    }
+    return result;
+  };
+  Rec2.pick = (...pickedKeys) => (data) => {
+    const result = {};
+    for (const key of pickedKeys) {
+      if (Object.hasOwn(data, key)) {
+        Object.defineProperty(result, key, { value: data[key], writable: true, enumerable: true, configurable: true });
+      }
+    }
+    return result;
+  };
+  Rec2.omit = (...omittedKeys) => (data) => {
+    const omitSet = new Set(omittedKeys);
+    const result = {};
+    for (const key of Object.keys(data)) {
+      if (!omitSet.has(key)) {
+        Object.defineProperty(result, key, {
+          value: data[key],
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return result;
+  };
+  Rec2.merge = (other) => (data) => ({
+    ...data,
+    ...other
+  });
+  function mergeWith(combine) {
+    return (arg1, arg2) => {
+      if (arg2 !== void 0) {
+        const first = arg1;
+        const second2 = arg2;
+        const result = { ...first };
+        for (const [k, v] of Object.entries(second2)) {
+          if (Object.hasOwn(result, k)) {
+            result[k] = combine(result[k], v);
+          } else {
+            result[k] = v;
+          }
+        }
+        return result;
+      }
+      const second = arg1;
+      return (first) => {
+        const result = { ...first };
+        for (const [k, v] of Object.entries(second)) {
+          if (Object.hasOwn(result, k)) {
+            result[k] = combine(result[k], v);
+          } else {
+            result[k] = v;
+          }
+        }
+        return result;
+      };
+    };
+  }
+  Rec2.mergeWith = mergeWith;
+  Rec2.size = (data) => Object.keys(data).length;
+  Rec2.mapKeys = (f) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      Object.defineProperty(result, f(k), { value: v, writable: true, enumerable: true, configurable: true });
+    }
+    return result;
+  };
+  Rec2.compact = (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (v.kind === "Some") {
+        Object.defineProperty(result, k, { value: v.value, writable: true, enumerable: true, configurable: true });
+      }
+    }
+    return result;
+  };
+  Rec2.mapEntries = (f) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      const [newKey, newVal] = f(k, v);
+      Object.defineProperty(result, newKey, { value: newVal, writable: true, enumerable: true, configurable: true });
+    }
+    return result;
+  };
+  Rec2.updateIn = (path, f) => (data) => {
+    const updateNode = (obj, keys2) => {
+      const [head, ...tail] = keys2;
+      if (tail.length === 0) {
+        return { ...obj, [head]: f(obj?.[head]) };
+      }
+      const child = obj && typeof obj === "object" && head in obj ? obj[head] : {};
+      return { ...obj, [head]: updateNode(child, tail) };
+    };
+    return updateNode(data, path);
+  };
+  let traverse;
+  ((traverse2) => {
+    traverse2.Maybe = RecMaybe.traverse;
+    traverse2.Result = RecResult.traverse;
+  })(traverse = Rec2.traverse || (Rec2.traverse = {}));
+  let sequence;
+  ((sequence2) => {
+    sequence2.Maybe = RecMaybe.sequence;
+    sequence2.Result = RecResult.sequence;
+  })(sequence = Rec2.sequence || (Rec2.sequence = {}));
+  Rec2.NonEmpty = RecNonEmpty;
+})(Rec || (Rec = {}));
+
+// src/Data/Str.ts
+var StrNonEmpty;
+((StrNonEmpty2) => {
+  let from;
+  ((from2) => {
+    from2.String = (s) => s.length > 0 ? Maybe.make.some(s) : Maybe.make.none();
+  })(from = StrNonEmpty2.from || (StrNonEmpty2.from = {}));
+})(StrNonEmpty || (StrNonEmpty = {}));
+var Str;
+((Str2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (s) => s.length === 0;
+    is2.nonEmpty = (s) => s.length > 0;
+  })(is = Str2.is || (Str2.is = {}));
+  Str2.split = (separator) => (s) => s.split(separator);
+  Str2.trim = (s) => s.trim();
+  Str2.includes = (substring) => (s) => s.includes(substring);
+  Str2.replace = (pattern, replacement) => (s) => s.replace(pattern, replacement);
+  Str2.replaceAll = (pattern, replacement) => (s) => s.replaceAll(pattern, replacement);
+  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.capitalize = (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1);
+  Str2.lines = (s) => s.split(/\r?\n|\r/);
+  Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
+  Str2.isBlank = (s) => s.trim().length === 0;
+  Str2.length = (s) => s.length;
+  Str2.slice = (start, end) => (s) => s.slice(start, end);
+  Str2.padStart = (maxLength, fillString) => (s) => s.padStart(maxLength, fillString);
+  Str2.padEnd = (maxLength, fillString) => (s) => s.padEnd(maxLength, fillString);
+  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) ? Maybe.make.none() : Maybe.make.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) ? Maybe.make.none() : Maybe.make.some(n);
+    }
+  };
+  Str2.parseJson = (s) => {
+    try {
+      return Result.make.ok(JSON.parse(s));
+    } catch (error) {
+      return Result.make.err(error);
+    }
+  };
+  Str2.uncapitalize = (s) => s.length === 0 ? "" : s.charAt(0).toLowerCase() + s.slice(1);
+  Str2.truncate = (options) => (s) => {
+    const { length: targetLength, suffix = "..." } = options;
+    if (s.length <= targetLength) {
+      return s;
+    }
+    if (targetLength <= suffix.length) {
+      return suffix.slice(0, targetLength);
+    }
+    return s.slice(0, targetLength - suffix.length) + suffix;
+  };
+  Str2.NonEmpty = StrNonEmpty;
+})(Str || (Str = {}));
+
+// src/Data/Uniq.ts
+var UniqNonEmpty;
+((UniqNonEmpty2) => {
+  UniqNonEmpty2.singleton = (item) => new globalThis.Set([item]);
+  let from;
+  ((from2) => {
+    from2.Set = (s) => s.size > 0 ? Maybe.make.some(s) : Maybe.make.none();
+  })(from = UniqNonEmpty2.from || (UniqNonEmpty2.from = {}));
+  UniqNonEmpty2.reduce = (f) => (s) => to.Array(s).reduce(f);
+  UniqNonEmpty2.map = (f) => (s) => Uniq.map(f)(s);
+  let to;
+  ((to2) => {
+    to2.Array = (s) => Uniq.to.Array(s);
+  })(to = UniqNonEmpty2.to || (UniqNonEmpty2.to = {}));
+})(UniqNonEmpty || (UniqNonEmpty = {}));
+var Uniq;
+((Uniq2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (s) => s.size === 0;
+    is2.nonEmpty = (s) => s.size > 0;
+  })(is = Uniq2.is || (Uniq2.is = {}));
+  Uniq2.empty = () => new globalThis.Set();
+  Uniq2.singleton = (item) => new globalThis.Set([item]);
+  let from;
+  ((from2) => {
+    from2.Array = (arr) => new globalThis.Set(arr);
+  })(from = Uniq2.from || (Uniq2.from = {}));
+  Uniq2.has = (item) => (s) => s.has(item);
+  Uniq2.size = (s) => s.size;
+  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;
+  };
+  let to;
+  ((to2) => {
+    to2.Array = (s) => [...s];
+  })(to = Uniq2.to || (Uniq2.to = {}));
+  Uniq2.NonEmpty = UniqNonEmpty;
+})(Uniq || (Uniq = {}));
+export {
+  Arr,
+  BigNum,
+  Brand,
+  Combinable,
+  Deferred,
+  Dict,
+  Duration,
+  Equality,
+  Json,
+  Lazy,
+  Lens,
+  Logged,
+  Maybe,
+  Num,
+  Op,
+  Optional,
+  Ordering,
+  Pair,
+  Predicate,
+  Reader,
+  Rec,
+  Refinement,
+  RemoteData,
+  Resource,
+  Result,
+  RetryPolicy,
+  State,
+  Str,
+  Stream,
+  Task,
+  These,
+  Uniq,
+  Validation,
+  and,
+  compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  converge,
+  curry,
+  curry3,
+  curry4,
+  defaultTo,
+  flip,
+  flow,
+  identity,
+  juxt,
+  memoize,
+  memoizeWeak,
+  not,
+  on,
+  once,
+  or,
+  pipe,
+  tap,
+  tuple,
+  uncurry,
+  uncurry3,
+  uncurry4,
+  untuple
+};