@nlozgachev/pipelined 0.53.0 → 0.55.0

package/dist/core.js

@@ -1,2667 +1,4 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Core/index.ts
-var Core_exports = {};
-__export(Core_exports, {
-  Combinable: () => Combinable,
-  Deferred: () => Deferred,
-  Equality: () => Equality,
-  Lazy: () => Lazy,
-  Lens: () => Lens,
-  Logged: () => Logged,
-  Maybe: () => Maybe,
-  Op: () => Op,
-  Optional: () => Optional,
-  Ordering: () => Ordering,
-  Predicate: () => Predicate,
-  Reader: () => Reader,
-  Refinement: () => Refinement,
-  RemoteData: () => RemoteData,
-  Resource: () => Resource,
-  Result: () => Result,
-  State: () => State,
-  Stream: () => Stream,
-  Task: () => Task,
-  These: () => These,
-  Tuple: () => Tuple,
-  Validation: () => Validation
-});
-module.exports = __toCommonJS(Core_exports);
-
-// 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;
-((Equality2) => {
-  Equality2.string = (a, b) => a === b;
-  Equality2.number = (a, b) => a === b;
-  Equality2.boolean = (a, b) => a === b;
-  Equality2.date = (a, b) => a.getTime() === b.getTime();
-  Equality2.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
-  Equality2.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
-  Equality2.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
-  Equality2.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;
-  };
-  Equality2.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/Types/Brand.ts
-var Brand;
-((Brand2) => {
-  Brand2.wrap = () => (value) => value;
-  Brand2.unwrap = (branded) => branded;
-})(Brand || (Brand = {}));
-
-// src/Types/Duration.ts
-var Duration;
-((Duration2) => {
-  const wrap = Brand.wrap();
-  Duration2.milliseconds = (ms) => wrap(ms);
-  Duration2.seconds = (s) => wrap(s * 1e3);
-  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
-  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
-  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
-  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/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;
-((Ordering2) => {
-  Ordering2.string = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-  Ordering2.number = (a, b) => a - b;
-  Ordering2.date = (a, b) => a.getTime() - b.getTime();
-  Ordering2.reverse = (ord) => (a, b) => ord(b, a);
-  Ordering2.thenBy = (ord2) => (ord1) => (a, b) => {
-    const r = ord1(a, b);
-    return r !== 0 ? r : ord2(a, b);
-  };
-  Ordering2.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
-  Ordering2.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;
-  };
-  Ordering2.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/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) => Task.from.Promise(
-    (signal) => 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: Task.from.Promise(
-      (signal) => 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]) => Task.from.Promise(
-      (signal) => 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.throwable = (f, options) => (...args) => {
-      try {
-        return make.ok(f(...args));
-      } catch (error) {
-        return make.err(options.onError(error));
-      }
-    };
-    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) => Task.from.Promise(
-    (signal) => 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) => Task.from.Promise(
-    (signal) => 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) => Task.from.Promise((signal) => {
-    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);
-    });
-  });
-})(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);
-    from2.throwable = (f, options) => (...args) => Task.from.Promise(
-      () => f(...args).then(Result.make.ok).catch((error) => Result.make.err(options.onError(error)))
-    );
-  })(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) => Task.from.Promise(
-    (signal) => Promise.resolve(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.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
-  TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
-  TaskResult2.ap = (arg) => (data) => Task.from.Promise(
-    (signal) => 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) => Task.from.Promise((signal) => {
-    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) => Task.from.Promise((signal) => {
-    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) => Task.from.Promise((signal) => {
-    const ms = Duration.to.milliseconds(options.duration);
-    return new Promise((resolve) => {
-      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) => Task.from.Promise((signal) => 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 = {}));
-  TaskValidation2.tryCatch = (f, onError) => Task.from.Promise(
-    (signal) => Promise.resolve(f(signal)).then(Validation.make.passed).catch(
-      (error) => Validation.make.failed(onError(error))
-    )
-  );
-  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
-  TaskValidation2.ap = (arg) => (data) => Task.from.Promise(
-    (signal) => 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.product = (first, second) => Task.from.Promise(
-    (signal) => Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
-      ([va, vb]) => Validation.product(va, vb)
-    )
-  );
-  TaskValidation2.productAll = (data) => Task.from.Promise(
-    (signal) => 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) => Task.from.Promise((signal) => {
-    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);
-    });
-  });
-})(TaskValidation || (TaskValidation = {}));
-
-// src/Core/Task.ts
-var toPromise = (task, signal) => Deferred.to.Promise(task(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.Promise = (f) => (signal) => Deferred.from.Promise(f(signal));
-    from2.sync = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
-  })(from = Task2.from || (Task2.from = {}));
-  Task2.map = (f) => (data) => from.Promise((signal) => toPromise(data, signal).then(f));
-  Task2.chain = (f) => (data) => from.Promise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
-  Task2.ap = (arg) => (data) => from.Promise((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
-  Task2.tap = (f) => (data) => from.Promise(
-    (signal) => toPromise(data, signal).then((a) => {
-      f(a);
-      return a;
-    })
-  );
-  Task2.all = (tasks) => from.Promise(
-    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
-  );
-  Task2.delay = (duration) => (data) => from.Promise(
-    (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) => from.Promise((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) => from.Promise((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 from.Promise((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) => from.Promise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
-  Task2.sequential = (tasks) => from.Promise(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) => from.Promise((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/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  let from;
-  ((from2) => {
-    from2.pair = (first2, second2) => [first2, second2];
-    from2.array = (arr) => arr;
-  })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
-  ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  let to;
-  ((to2) => {
-    to2.Array = (tuple) => [...tuple];
-  })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
-  };
-})(Tuple || (Tuple = {}));
-
-// 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 = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import {
   Combinable,
   Deferred,
   Equality,
@@ -2684,4 +21,29 @@ var Validation;
   These,
   Tuple,
   Validation
-});
+} from "./chunk-MFJXL6J2.js";
+import "./chunk-OIIOGDHK.js";
+export {
+  Combinable,
+  Deferred,
+  Equality,
+  Lazy,
+  Lens,
+  Logged,
+  Maybe,
+  Op,
+  Optional,
+  Ordering,
+  Predicate,
+  Reader,
+  Refinement,
+  RemoteData,
+  Resource,
+  Result,
+  State,
+  Stream,
+  Task,
+  These,
+  Tuple,
+  Validation
+};