@nlozgachev/pipelined 0.53.0 → 0.55.0

package/dist/data.js

@@ -1,2139 +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/Data/index.ts
-var Data_exports = {};
-__export(Data_exports, {
-  Arr: () => Arr,
-  BigNum: () => BigNum,
-  Dict: () => Dict,
-  Json: () => Json,
-  Num: () => Num,
-  Rec: () => Rec,
-  Str: () => Str,
-  Uniq: () => Uniq
-});
-module.exports = __toCommonJS(Data_exports);
-
-// 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/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/Core/Result.ts
-var Result;
-((Result3) => {
-  let make;
-  ((make2) => {
-    make2.ok = (value) => ({ kind: "Ok", value });
-    make2.err = (e) => ({ kind: "Err", error: e });
-  })(make = Result3.make || (Result3.make = {}));
-  let is;
-  ((is2) => {
-    is2.ok = (data) => data.kind === "Ok";
-    is2.err = (data) => data.kind === "Err";
-  })(is = Result3.is || (Result3.is = {}));
-  Result3.tryCatch = (f, options) => {
-    try {
-      return make.ok(f());
-    } catch (error) {
-      return make.err(options.onError(error));
-    }
-  };
-  Result3.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
-  Result3.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
-  Result3.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
-  Result3.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
-  Result3.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
-  Result3.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
-  Result3.tap = (f) => (data) => {
-    if (is.ok(data)) {
-      f(data.value);
-    }
-    return data;
-  };
-  Result3.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 = Result3.from || (Result3.from = {}));
-  Result3.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
-  Result3.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 = Result3.to || (Result3.to = {}));
-  Result3.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();
-  Result3.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
-  Result3.bindTo = (key) => (data) => (0, Result3.map)((a) => ({ [key]: a }))(data);
-  Result3.bind = (key, f) => (data) => (0, Result3.chain)(
-    (a) => (0, Result3.map)((b) => ({ ...a, [key]: b }))(f(a))
-  )(data);
-  Result3.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);
-  };
-  Result3.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
-  Result3.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
-})(Result || (Result = {}));
-
-// 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 getMs = (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));
-      }, getMs(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 ? getMs(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 ? getMs(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()));
-        }, getMs(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/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 Result3(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 = Result3;
-    to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
-  })(to = Validation2.to || (Validation2.to = {}));
-  Validation2.product = (first, second) => {
-    if (is.passed(first)) {
-      return is.passed(second) ? make.passed([first.value, second.value]) : make.failedAll(second.errors);
-    }
-    return is.passed(second) ? make.failedAll(first.errors) : make.failedAll([...first.errors, ...second.errors]);
-  };
-  Validation2.productAll = (data) => {
-    const values = [];
-    const errors = [];
-    for (const v of data) {
-      if (is.passed(v)) {
-        values.push(v.value);
-      } else {
-        errors.push(...v.errors);
-      }
-    }
-    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(values);
-  };
-  Validation2.struct = (fields) => {
-    const record = {};
-    const errors = [];
-    for (const key in fields) {
-      if (Object.hasOwn(fields, key)) {
-        const val = fields[key];
-        if (is.passed(val)) {
-          record[key] = val.value;
-        } else {
-          errors.push(...val.errors);
-        }
-      }
-    }
-    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
-  };
-})(Validation || (Validation = {}));
-
-// src/Data/Arr.ts
-var ArrMaybe;
-((ArrMaybe2) => {
-  ArrMaybe2.traverse = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "None") {
-        return Maybe.make.none();
-      }
-      result[i] = mapped.value;
-    }
-    return Maybe.make.some(result);
-  };
-  ArrMaybe2.sequence = (data) => (0, ArrMaybe2.traverse)((a) => a)(data);
-})(ArrMaybe || (ArrMaybe = {}));
-var ArrResult;
-((ArrResult2) => {
-  ArrResult2.traverse = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "Err") {
-        return mapped;
-      }
-      result[i] = mapped.value;
-    }
-    return Result.make.ok(result);
-  };
-  ArrResult2.sequence = (data) => (0, ArrResult2.traverse)((a) => a)(data);
-})(ArrResult || (ArrResult = {}));
-var ArrTaskResult;
-((ArrTaskResult2) => {
-  ArrTaskResult2.traverse = (f) => (data) => Task.from.Promise(async () => {
-    const result = [];
-    for (const a of data) {
-      const r = await Deferred.to.Promise(f(a)());
-      if (Result.is.err(r)) {
-        return r;
-      }
-      result.push(r.value);
-    }
-    return Result.make.ok(result);
-  });
-  ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
-})(ArrTaskResult || (ArrTaskResult = {}));
-var ArrTask;
-((ArrTask2) => {
-  ArrTask2.traverse = (f) => (data) => Task.from.Promise(() => Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
-  ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
-  ArrTask2.Result = ArrTaskResult;
-})(ArrTask || (ArrTask = {}));
-var ArrNonEmpty;
-((ArrNonEmpty2) => {
-  ArrNonEmpty2.singleton = (value) => [value];
-  let from;
-  ((from2) => {
-    from2.Array = (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none();
-  })(from = ArrNonEmpty2.from || (ArrNonEmpty2.from = {}));
-  ArrNonEmpty2.head = (data) => data[0];
-  ArrNonEmpty2.last = (data) => data[data.length - 1];
-  ArrNonEmpty2.tail = (data) => data.slice(1);
-  ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
-  ArrNonEmpty2.map = (f) => (data) => Arr.map(f)(data);
-  ArrNonEmpty2.mapWithIndex = (f) => (data) => Arr.mapWithIndex(f)(data);
-  ArrNonEmpty2.intersperse = (sep) => (data) => Arr.intersperse(sep)(data);
-  ArrNonEmpty2.concat = (other) => (data) => Arr.concat(other)(data);
-  ArrNonEmpty2.reverse = (data) => Arr.reverse(data);
-})(ArrNonEmpty || (ArrNonEmpty = {}));
-var Arr;
-((Arr2) => {
-  Arr2.head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
-  Arr2.last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
-  Arr2.tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
-  Arr2.init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
-  Arr2.findFirst = (predicate) => (data) => {
-    const idx = data.findIndex(predicate);
-    return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
-  };
-  Arr2.findLast = (predicate) => (data) => {
-    for (let i = data.length - 1; i >= 0; i--) {
-      if (predicate(data[i])) {
-        return Maybe.make.some(data[i]);
-      }
-    }
-    return Maybe.make.none();
-  };
-  Arr2.findIndex = (predicate) => (data) => {
-    const idx = data.findIndex(predicate);
-    return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.none();
-  };
-  Arr2.map = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      result[i] = f(data[i]);
-    }
-    return result;
-  };
-  Arr2.mapWithIndex = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      result[i] = f(i, data[i]);
-    }
-    return result;
-  };
-  Arr2.filter = (predicate) => (data) => {
-    const n = data.length;
-    const result = [];
-    for (let i = 0; i < n; i++) {
-      if (predicate(data[i])) {
-        result.push(data[i]);
-      }
-    }
-    return result;
-  };
-  Arr2.filterMap = (f) => (data) => {
-    const result = [];
-    for (let i = 0; i < data.length; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "Some") {
-        result.push(mapped.value);
-      }
-    }
-    return result;
-  };
-  Arr2.partition = (predicate) => (data) => {
-    const pass = [];
-    const fail = [];
-    for (const a of data) {
-      (predicate(a) ? pass : fail).push(a);
-    }
-    return [pass, fail];
-  };
-  Arr2.compact = (data) => {
-    const result = [];
-    for (const item of data) {
-      if (item.kind === "Some") {
-        result.push(item.value);
-      }
-    }
-    return result;
-  };
-  Arr2.separate = (data) => {
-    const errors = [];
-    const successes = [];
-    for (const item of data) {
-      if (item.kind === "Ok") {
-        successes.push(item.value);
-      } else {
-        errors.push(item.error);
-      }
-    }
-    return [errors, successes];
-  };
-  Arr2.partitionMap = (f) => (data) => {
-    const errors = [];
-    const successes = [];
-    for (const item of data) {
-      const mapped = f(item);
-      if (mapped.kind === "Ok") {
-        successes.push(mapped.value);
-      } else {
-        errors.push(mapped.error);
-      }
-    }
-    return [errors, successes];
-  };
-  Arr2.groupBy = (f) => (data) => {
-    const result = {};
-    for (const a of data) {
-      const key = f(a);
-      if (!result[key]) {
-        result[key] = [];
-      }
-      result[key].push(a);
-    }
-    return result;
-  };
-  Arr2.uniq = (data) => [...new Set(data)];
-  Arr2.uniqBy = (f) => (data) => {
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const a of data) {
-      const key = f(a);
-      if (!seen.has(key)) {
-        seen.add(key);
-        result.push(a);
-      }
-    }
-    return result;
-  };
-  Arr2.uniqWith = (eq) => (data) => {
-    const result = [];
-    for (const a of data) {
-      if (!result.some((x) => eq(x, a))) {
-        result.push(a);
-      }
-    }
-    return result;
-  };
-  Arr2.sortBy = (compare) => (data) => {
-    const arr = data;
-    if (typeof arr.toSorted === "function") {
-      return arr.toSorted(compare);
-    }
-    return [...data].toSorted(compare);
-  };
-  Arr2.sortWith = (ord) => (data) => {
-    const arr = data;
-    if (typeof arr.toSorted === "function") {
-      return arr.toSorted(ord);
-    }
-    return [...data].sort(ord);
-  };
-  Arr2.zip = (other) => (data) => {
-    const len = Math.min(data.length, other.length);
-    const result = new Array(len);
-    for (let i = 0; i < len; i++) {
-      result[i] = [data[i], other[i]];
-    }
-    return result;
-  };
-  Arr2.zipWith = (f) => (other) => (data) => {
-    const len = Math.min(data.length, other.length);
-    const result = new Array(len);
-    for (let i = 0; i < len; i++) {
-      result[i] = f(data[i], other[i]);
-    }
-    return result;
-  };
-  Arr2.intersperse = (sep) => (data) => {
-    if (data.length <= 1) {
-      return data;
-    }
-    const result = [data[0]];
-    for (let i = 1; i < data.length; i++) {
-      result.push(sep, data[i]);
-    }
-    return result;
-  };
-  Arr2.concat = (other) => (data) => [...data, ...other];
-  Arr2.chunksOf = (n) => (data) => {
-    if (n <= 0) {
-      return [];
-    }
-    const result = [];
-    for (let i = 0; i < data.length; i += n) {
-      result.push(data.slice(i, i + n));
-    }
-    return result;
-  };
-  Arr2.flatten = (data) => {
-    let totalLen = 0;
-    const outerLen = data.length;
-    for (let i = 0; i < outerLen; i++) {
-      totalLen += data[i].length;
-    }
-    const result = new Array(totalLen);
-    let idx = 0;
-    for (let i = 0; i < outerLen; i++) {
-      const chunk = data[i];
-      const innerLen = chunk.length;
-      for (let j = 0; j < innerLen; j++) {
-        result[idx++] = chunk[j];
-      }
-    }
-    return result;
-  };
-  Arr2.flatMap = (f) => (data) => {
-    const n = data.length;
-    const result = [];
-    for (let i = 0; i < n; i++) {
-      const chunk = f(data[i]);
-      const m = chunk.length;
-      for (let j = 0; j < m; j++) {
-        result.push(chunk[j]);
-      }
-    }
-    return result;
-  };
-  Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
-  const _traverseTask = Object.assign((f) => ArrTask.traverse(f), {
-    Result: ArrTaskResult.traverse
-  });
-  const _sequenceTask = Object.assign((data) => ArrTask.sequence(data), {
-    Result: ArrTaskResult.sequence
-  });
-  let traverse;
-  ((traverse2) => {
-    traverse2.Maybe = ArrMaybe.traverse;
-    traverse2.Result = ArrResult.traverse;
-    traverse2.Task = _traverseTask;
-  })(traverse = Arr2.traverse || (Arr2.traverse = {}));
-  let sequence;
-  ((sequence2) => {
-    sequence2.Maybe = ArrMaybe.sequence;
-    sequence2.Result = ArrResult.sequence;
-    sequence2.Task = _sequenceTask;
-  })(sequence = Arr2.sequence || (Arr2.sequence = {}));
-  let is;
-  ((is2) => {
-    is2.empty = (data) => data.length === 0;
-    is2.nonEmpty = (data) => isNonEmptyArr(data);
-  })(is = Arr2.is || (Arr2.is = {}));
-  Arr2.prepend = (value) => (data) => [value, ...data];
-  Arr2.append = (value) => (data) => [...data, value];
-  Arr2.size = (data) => data.length;
-  Arr2.some = (predicate) => (data) => {
-    const n = data.length;
-    for (let i = 0; i < n; i++) {
-      if (predicate(data[i])) {
-        return true;
-      }
-    }
-    return false;
-  };
-  Arr2.every = (predicate) => (data) => {
-    const n = data.length;
-    for (let i = 0; i < n; i++) {
-      if (!predicate(data[i])) {
-        return false;
-      }
-    }
-    return true;
-  };
-  Arr2.reverse = (data) => [...data].toReversed();
-  Arr2.insertAt = (index, item) => (data) => {
-    const i = Math.max(0, Math.min(index, data.length));
-    const arr = data;
-    if (typeof arr.toSpliced === "function") {
-      return arr.toSpliced(i, 0, item);
-    }
-    const result = [...data];
-    result.splice(i, 0, item);
-    return result;
-  };
-  Arr2.removeAt = (index) => (data) => {
-    if (index < 0 || index >= data.length) {
-      return data;
-    }
-    const arr = data;
-    if (typeof arr.toSpliced === "function") {
-      return arr.toSpliced(index, 1);
-    }
-    const result = [...data];
-    result.splice(index, 1);
-    return result;
-  };
-  Arr2.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
-  Arr2.drop = (n) => (data) => data.slice(n);
-  Arr2.takeWhile = (predicate) => (data) => {
-    const result = [];
-    for (const a of data) {
-      if (!predicate(a)) {
-        break;
-      }
-      result.push(a);
-    }
-    return result;
-  };
-  Arr2.dropWhile = (predicate) => (data) => {
-    let i = 0;
-    while (i < data.length && predicate(data[i])) {
-      i++;
-    }
-    return data.slice(i);
-  };
-  Arr2.scan = (initial, f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    let acc = initial;
-    for (let i = 0; i < n; i++) {
-      acc = f(acc, data[i]);
-      result[i] = acc;
-    }
-    return result;
-  };
-  Arr2.splitAt = (index) => (data) => {
-    const i = Math.max(0, index);
-    return [data.slice(0, i), data.slice(i)];
-  };
-  Arr2.partitionMaybe = (f) => (data) => {
-    const failures = [];
-    const successes = [];
-    for (let i = 0; i < data.length; i++) {
-      const res = f(data[i]);
-      if (res.kind === "Some") {
-        successes.push(res.value);
-      } else {
-        failures.push(data[i]);
-      }
-    }
-    return [failures, successes];
-  };
-  Arr2.at = (index) => (data) => {
-    const targetIndex = index < 0 ? data.length + index : index;
-    if (targetIndex < 0 || targetIndex >= data.length) {
-      return Maybe.make.none();
-    }
-    return Maybe.make.some(data[targetIndex]);
-  };
-  Arr2.findMap = (f) => (data) => {
-    for (let i = 0; i < data.length; i++) {
-      const res = f(data[i]);
-      if (res.kind === "Some") {
-        return res;
-      }
-    }
-    return Maybe.make.none();
-  };
-  Arr2.indexBy = (keyFn) => (data) => {
-    const map2 = new globalThis.Map();
-    for (let i = 0; i < data.length; i++) {
-      map2.set(keyFn(data[i]), data[i]);
-    }
-    return map2;
-  };
-  Arr2.frequencies = (data) => {
-    const map2 = new globalThis.Map();
-    for (let i = 0; i < data.length; i++) {
-      const item = data[i];
-      map2.set(item, (map2.get(item) ?? 0) + 1);
-    }
-    return map2;
-  };
-  Arr2.chunkBy = (keyFn) => (data) => {
-    if (data.length === 0) {
-      return [];
-    }
-    const result = [];
-    let currentChunk = [data[0]];
-    let currentKey = keyFn(data[0]);
-    for (let i = 1; i < data.length; i++) {
-      const item = data[i];
-      const key = keyFn(item);
-      if (Object.is(key, currentKey)) {
-        currentChunk.push(item);
-      } else {
-        result.push(currentChunk);
-        currentChunk = [item];
-        currentKey = key;
-      }
-    }
-    result.push(currentChunk);
-    return result;
-  };
-  Arr2.dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
-    if (data.length === 0) {
-      return [];
-    }
-    const result = [data[0]];
-    for (let i = 1; i < data.length; i++) {
-      if (!eq(data[i], result[result.length - 1])) {
-        result.push(data[i]);
-      }
-    }
-    return result;
-  };
-  Arr2.windowed = (size2, options) => (data) => {
-    const step = options?.step ?? 1;
-    if (size2 <= 0 || step <= 0 || data.length < size2) {
-      return [];
-    }
-    const result = [];
-    for (let i = 0; i <= data.length - size2; i += step) {
-      result.push(data.slice(i, i + size2));
-    }
-    return result;
-  };
-  Arr2.unfold = (initial, f) => {
-    const result = [];
-    let currentState = initial;
-    while (true) {
-      const next = f(currentState);
-      if (next.kind === "None") {
-        break;
-      }
-      const [item, nextState] = next.value;
-      result.push(item);
-      currentState = nextState;
-    }
-    return result;
-  };
-  Arr2.NonEmpty = ArrNonEmpty;
-})(Arr || (Arr = {}));
-
-// src/Data/BigNum.ts
-var BigNum;
-((BigNum2) => {
-  let from;
-  ((from2) => {
-    from2.string = (s) => {
-      try {
-        if (s.trim() === "") {
-          return Maybe.make.none();
-        }
-        return Maybe.make.some(BigInt(s));
-      } catch {
-        return Maybe.make.none();
-      }
-    };
-    from2.number = (n) => {
-      if (!Number.isInteger(n) || n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
-        return Maybe.make.none();
-      }
-      return Maybe.make.some(BigInt(n));
-    };
-  })(from = BigNum2.from || (BigNum2.from = {}));
-  let to;
-  ((to2) => {
-    to2.number = (b) => {
-      if (b < BigInt(Number.MIN_SAFE_INTEGER) || b > BigInt(Number.MAX_SAFE_INTEGER)) {
-        return Maybe.make.none();
-      }
-      return Maybe.make.some(Number(b));
-    };
-  })(to = BigNum2.to || (BigNum2.to = {}));
-  BigNum2.add = (b) => (a) => a + b;
-  BigNum2.sub = (b) => (a) => a - b;
-  BigNum2.mul = (b) => (a) => a * b;
-  BigNum2.div = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a / b);
-  BigNum2.mod = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a % b);
-  BigNum2.clamp = (min2, max2) => (a) => a < min2 ? min2 : a > max2 ? max2 : a;
-  BigNum2.inRange = (start, end) => (a) => a >= start && a < end;
-  BigNum2.abs = (a) => a < 0n ? -a : a;
-  BigNum2.min = (b) => (a) => a < b ? a : b;
-  BigNum2.max = (b) => (a) => a > b ? a : b;
-})(BigNum || (BigNum = {}));
-
-// src/Data/Dict.ts
-var DictNonEmpty;
-((DictNonEmpty2) => {
-  DictNonEmpty2.singleton = (key, value) => new globalThis.Map([[key, value]]);
-  let from;
-  ((from2) => {
-    from2.Map = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
-  })(from = DictNonEmpty2.from || (DictNonEmpty2.from = {}));
-  DictNonEmpty2.keys = (m) => Dict.keys(m);
-  DictNonEmpty2.values = (m) => Dict.values(m);
-  DictNonEmpty2.entries = (m) => Dict.entries(m);
-  DictNonEmpty2.reduce = (f) => (m) => (0, DictNonEmpty2.values)(m).reduce(f);
-  DictNonEmpty2.map = (f) => (m) => Dict.map(f)(m);
-  DictNonEmpty2.mapWithKey = (f) => (m) => Dict.mapWithKey(f)(m);
-})(DictNonEmpty || (DictNonEmpty = {}));
-var Dict;
-((Dict2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (m) => m.size === 0;
-    is2.nonEmpty = (m) => m.size > 0;
-  })(is = Dict2.is || (Dict2.is = {}));
-  Dict2.empty = () => new globalThis.Map();
-  Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
-  let from;
-  ((from2) => {
-    from2.entries = (entries3) => new globalThis.Map(entries3);
-    from2.Record = (rec) => new globalThis.Map(Object.entries(rec));
-  })(from = Dict2.from || (Dict2.from = {}));
-  Dict2.groupBy = (keyFn) => (items) => {
-    const result = new globalThis.Map();
-    for (const item of items) {
-      const key = keyFn(item);
-      const arr = result.get(key);
-      if (arr !== void 0) {
-        arr.push(item);
-      } else {
-        result.set(key, [item]);
-      }
-    }
-    return result;
-  };
-  Dict2.has = (key) => (m) => m.has(key);
-  Dict2.lookup = (key) => (m) => m.has(key) ? Maybe.make.some(m.get(key)) : Maybe.make.none();
-  Dict2.size = (m) => m.size;
-  Dict2.keys = (m) => [...m.keys()];
-  Dict2.values = (m) => [...m.values()];
-  Dict2.entries = (m) => [...m.entries()];
-  Dict2.insert = (key, value) => (m) => {
-    const result = new globalThis.Map(m);
-    result.set(key, value);
-    return result;
-  };
-  Dict2.remove = (key) => (m) => {
-    if (!m.has(key)) {
-      return m;
-    }
-    const result = new globalThis.Map(m);
-    result.delete(key);
-    return result;
-  };
-  Dict2.upsert = (key, f) => (m) => {
-    const result = new globalThis.Map(m);
-    result.set(key, f((0, Dict2.lookup)(key)(m)));
-    return result;
-  };
-  Dict2.map = (f) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      result.set(k, f(v));
-    }
-    return result;
-  };
-  Dict2.mapWithKey = (f) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      result.set(k, f(k, v));
-    }
-    return result;
-  };
-  Dict2.filter = (predicate) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (predicate(v)) {
-        result.set(k, v);
-      }
-    }
-    return result;
-  };
-  Dict2.filterWithKey = (predicate) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (predicate(k, v)) {
-        result.set(k, v);
-      }
-    }
-    return result;
-  };
-  Dict2.compact = (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (v.kind === "Some") {
-        result.set(k, v.value);
-      }
-    }
-    return result;
-  };
-  Dict2.filterMap = (f) => (m) => {
-    const result = new globalThis.Map();
-    for (const [key, value] of m) {
-      const mapped = f(value);
-      if (mapped.kind === "Some") {
-        result.set(key, mapped.value);
-      }
-    }
-    return result;
-  };
-  Dict2.union = (other) => (m) => {
-    const result = new globalThis.Map(m);
-    for (const [k, v] of other) {
-      result.set(k, v);
-    }
-    return result;
-  };
-  Dict2.intersection = (other) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (other.has(k)) {
-        result.set(k, v);
-      }
-    }
-    return result;
-  };
-  Dict2.difference = (other) => (m) => {
-    const result = new globalThis.Map();
-    for (const [k, v] of m) {
-      if (!other.has(k)) {
-        result.set(k, v);
-      }
-    }
-    return result;
-  };
-  Dict2.reduce = (init, f) => (m) => {
-    let acc = init;
-    for (const v of m.values()) {
-      acc = f(acc, v);
-    }
-    return acc;
-  };
-  Dict2.reduceWithKey = (init, f) => (m) => {
-    let acc = init;
-    for (const [k, v] of m) {
-      acc = f(acc, v, k);
-    }
-    return acc;
-  };
-  function mergeWith(combine) {
-    return (arg1, arg2) => {
-      if (arg2 !== void 0) {
-        const first = arg1;
-        const second2 = arg2;
-        const res = new globalThis.Map(first);
-        for (const [k, v] of second2) {
-          if (res.has(k)) {
-            res.set(k, combine(res.get(k), v));
-          } else {
-            res.set(k, v);
-          }
-        }
-        return res;
-      }
-      const second = arg1;
-      return (first) => {
-        const res = new globalThis.Map(first);
-        for (const [k, v] of second) {
-          if (res.has(k)) {
-            res.set(k, combine(res.get(k), v));
-          } else {
-            res.set(k, v);
-          }
-        }
-        return res;
-      };
-    };
-  }
-  Dict2.mergeWith = mergeWith;
-  let to;
-  ((to2) => {
-    to2.Record = (m) => Object.fromEntries(m);
-  })(to = Dict2.to || (Dict2.to = {}));
-  Dict2.mapEntries = (f) => (data) => {
-    const res = new globalThis.Map();
-    for (const [k, v] of data) {
-      const [nk, nv] = f(k, v);
-      res.set(nk, nv);
-    }
-    return res;
-  };
-  Dict2.mapKeys = (f) => (data) => {
-    const res = new globalThis.Map();
-    for (const [k, v] of data) {
-      res.set(f(k), v);
-    }
-    return res;
-  };
-  Dict2.NonEmpty = DictNonEmpty;
-})(Dict || (Dict = {}));
-
-// src/Data/Json.ts
-var isSyntaxError = (err) => typeof err === "object" && err !== null && "name" in err && err.name === "SyntaxError";
-var isTypeError = (err) => typeof err === "object" && err !== null && "name" in err && err.name === "TypeError";
-var Json;
-((Json2) => {
-  Json2.parse = (text) => Result.tryCatch(() => JSON.parse(text), {
-    onError: (err) => isSyntaxError(err) ? err : new SyntaxError(String(err))
-  });
-  Json2.stringify = (value, replacer, space) => Result.tryCatch(() => JSON.stringify(value, replacer, space), {
-    onError: (err) => isTypeError(err) ? err : new TypeError(String(err))
-  });
-})(Json || (Json = {}));
-
-// src/Data/Num.ts
-var Num;
-((Num2) => {
-  let is;
-  ((is2) => {
-    is2.zero = (n) => n === 0;
-    is2.integer = (n) => Number.isInteger(n);
-    is2.float = (n) => Number.isFinite(n) && !Number.isInteger(n);
-    is2.finite = (n) => Number.isFinite(n);
-    is2.nan = (n) => Number.isNaN(n);
-    is2.even = (n) => Number.isInteger(n) && n % 2 === 0;
-    is2.odd = (n) => Number.isInteger(n) && n % 2 !== 0;
-    is2.positive = (n) => n > 0;
-    is2.negative = (n) => n < 0;
-  })(is = Num2.is || (Num2.is = {}));
-  Num2.range = (from, to, step = 1) => {
-    if (step <= 0 || from > to) {
-      return [];
-    }
-    const count = Math.floor((to - from) / step) + 1;
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = from + i * step;
-    }
-    return result;
-  };
-  Num2.clamp = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
-  Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
-  Num2.inRange = (start, end) => (n) => n >= start && n < end;
-  Num2.parse = (s) => {
-    if (s.trim() === "") {
-      return Maybe.make.none();
-    }
-    const n = Number(s);
-    return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-  };
-  Num2.add = (b) => (a) => a + b;
-  Num2.subtract = (b) => (a) => a - b;
-  Num2.multiply = (b) => (a) => a * b;
-  Num2.divide = (b) => (a) => b === 0 ? Maybe.make.none() : Maybe.make.some(a / b);
-  Num2.abs = (n) => Math.abs(n);
-  Num2.negate = (n) => -n;
-  Num2.round = (n) => Math.round(n);
-  Num2.floor = (n) => Math.floor(n);
-  Num2.ceil = (n) => Math.ceil(n);
-  Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(n % divisor);
-  Num2.sum = (ns) => {
-    let result = 0;
-    for (let i = 0; i < ns.length; i++) {
-      result += ns[i];
-    }
-    return result;
-  };
-  Num2.mean = (ns) => ns.length === 0 ? Maybe.make.none() : Maybe.make.some((0, Num2.sum)(ns) / ns.length);
-  Num2.min = (ns) => {
-    if (ns.length === 0) {
-      return Maybe.make.none();
-    }
-    let [result] = ns;
-    for (let i = 1; i < ns.length; i++) {
-      if (ns[i] < result) {
-        result = ns[i];
-      }
-    }
-    return Maybe.make.some(result);
-  };
-  Num2.max = (ns) => {
-    if (ns.length === 0) {
-      return Maybe.make.none();
-    }
-    let [result] = ns;
-    for (let i = 1; i < ns.length; i++) {
-      if (ns[i] > result) {
-        result = ns[i];
-      }
-    }
-    return Maybe.make.some(result);
-  };
-  Num2.format = (options, locales) => (n) => !Number.isFinite(n) ? Maybe.make.none() : Maybe.make.some(new Intl.NumberFormat(locales, options).format(n));
-})(Num || (Num = {}));
-
-// src/Data/Rec.ts
-var _isNonEmpty = (data) => Object.keys(data).length > 0;
-var RecMaybe;
-((RecMaybe2) => {
-  RecMaybe2.traverse = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const result = {};
-    for (let i = 0; i < recordKeys.length; i++) {
-      const key = recordKeys[i];
-      const maybeVal = f(data[key]);
-      if (maybeVal.kind === "None") {
-        return maybeVal;
-      }
-      Object.defineProperty(result, key, { value: maybeVal.value, writable: true, enumerable: true, configurable: true });
-    }
-    return { kind: "Some", value: result };
-  };
-  RecMaybe2.sequence = (data) => (0, RecMaybe2.traverse)((a) => a)(data);
-})(RecMaybe || (RecMaybe = {}));
-var RecResult;
-((RecResult2) => {
-  RecResult2.traverse = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const result = {};
-    for (let i = 0; i < recordKeys.length; i++) {
-      const key = recordKeys[i];
-      const res = f(data[key]);
-      if (res.kind === "Err") {
-        return res;
-      }
-      Object.defineProperty(result, key, { value: res.value, writable: true, enumerable: true, configurable: true });
-    }
-    return { kind: "Ok", value: result };
-  };
-  RecResult2.sequence = (data) => (0, RecResult2.traverse)((a) => a)(data);
-})(RecResult || (RecResult = {}));
-var RecNonEmpty;
-((RecNonEmpty2) => {
-  RecNonEmpty2.singleton = (key, value) => ({ [key]: value });
-  let from;
-  ((from2) => {
-    from2.Record = (data) => _isNonEmpty(data) ? Maybe.make.some(data) : Maybe.make.none();
-  })(from = RecNonEmpty2.from || (RecNonEmpty2.from = {}));
-  RecNonEmpty2.keys = (data) => Rec.keys(data);
-  RecNonEmpty2.values = (data) => Rec.values(data);
-  RecNonEmpty2.entries = (data) => Rec.entries(data);
-  RecNonEmpty2.reduce = (f) => (data) => (0, RecNonEmpty2.values)(data).reduce(f);
-  RecNonEmpty2.map = (f) => (data) => Rec.map(f)(data);
-  RecNonEmpty2.mapWithKey = (f) => (data) => Rec.mapWithKey(f)(data);
-})(RecNonEmpty || (RecNonEmpty = {}));
-var Rec;
-((Rec2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (data) => Object.keys(data).length === 0;
-    is2.nonEmpty = _isNonEmpty;
-  })(is = Rec2.is || (Rec2.is = {}));
-  Rec2.map = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      const key = recordKeys[i];
-      if (key === "__proto__") {
-        Object.defineProperty(result, "__proto__", {
-          value: f(recordValues[i]),
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      } else {
-        result[key] = f(recordValues[i]);
-      }
-    }
-    return result;
-  };
-  Rec2.filterMap = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      const maybeVal = f(recordValues[i]);
-      if (maybeVal.kind === "Some") {
-        Object.defineProperty(result, recordKeys[i], {
-          value: maybeVal.value,
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      }
-    }
-    return result;
-  };
-  Rec2.mapWithKey = (f) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      const key = recordKeys[i];
-      if (key === "__proto__") {
-        Object.defineProperty(result, "__proto__", {
-          value: f(key, recordValues[i]),
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      } else {
-        result[key] = f(key, recordValues[i]);
-      }
-    }
-    return result;
-  };
-  Rec2.filter = (predicate) => (data) => {
-    const recordKeys = Object.keys(data);
-    const recordValues = Object.values(data);
-    const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < recordKeys.length; i++) {
-      if (predicate(recordValues[i])) {
-        Object.defineProperty(result, recordKeys[i], {
-          value: recordValues[i],
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      }
-    }
-    return result;
-  };
-  Rec2.filterWithKey = (predicate) => (data) => {
-    const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      if (predicate(k, v)) {
-        Object.defineProperty(result, k, { value: v, writable: true, enumerable: true, configurable: true });
-      }
-    }
-    return result;
-  };
-  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? { kind: "Some", value: data[key] } : { kind: "None" };
-  Rec2.keys = (data) => Object.keys(data);
-  Rec2.values = (data) => Object.values(data);
-  Rec2.entries = (data) => Object.entries(data);
-  let from;
-  ((from2) => {
-    from2.entries = (data) => Object.fromEntries(data);
-  })(from = Rec2.from || (Rec2.from = {}));
-  Rec2.groupBy = (keyFn) => (items) => {
-    const result = {};
-    for (const item of items) {
-      const key = keyFn(item);
-      if (Object.hasOwn(result, key)) {
-        result[key].push(item);
-      } else {
-        Object.defineProperty(result, key, { value: [item], writable: true, enumerable: true, configurable: true });
-      }
-    }
-    return result;
-  };
-  Rec2.pick = (...pickedKeys) => (data) => {
-    const result = {};
-    for (const key of pickedKeys) {
-      if (Object.hasOwn(data, key)) {
-        Object.defineProperty(result, key, { value: data[key], writable: true, enumerable: true, configurable: true });
-      }
-    }
-    return result;
-  };
-  Rec2.omit = (...omittedKeys) => (data) => {
-    const omitSet = new Set(omittedKeys);
-    const result = {};
-    for (const key of Object.keys(data)) {
-      if (!omitSet.has(key)) {
-        Object.defineProperty(result, key, {
-          value: data[key],
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      }
-    }
-    return result;
-  };
-  Rec2.merge = (other) => (data) => ({
-    ...data,
-    ...other
-  });
-  function mergeWith(combine) {
-    return (arg1, arg2) => {
-      if (arg2 !== void 0) {
-        const first = arg1;
-        const second2 = arg2;
-        const result = { ...first };
-        for (const [k, v] of Object.entries(second2)) {
-          if (Object.hasOwn(result, k)) {
-            result[k] = combine(result[k], v);
-          } else {
-            result[k] = v;
-          }
-        }
-        return result;
-      }
-      const second = arg1;
-      return (first) => {
-        const result = { ...first };
-        for (const [k, v] of Object.entries(second)) {
-          if (Object.hasOwn(result, k)) {
-            result[k] = combine(result[k], v);
-          } else {
-            result[k] = v;
-          }
-        }
-        return result;
-      };
-    };
-  }
-  Rec2.mergeWith = mergeWith;
-  Rec2.size = (data) => Object.keys(data).length;
-  Rec2.mapKeys = (f) => (data) => {
-    const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      Object.defineProperty(result, f(k), { value: v, writable: true, enumerable: true, configurable: true });
-    }
-    return result;
-  };
-  Rec2.compact = (data) => {
-    const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      if (v.kind === "Some") {
-        Object.defineProperty(result, k, { value: v.value, writable: true, enumerable: true, configurable: true });
-      }
-    }
-    return result;
-  };
-  Rec2.mapEntries = (f) => (data) => {
-    const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      const [newKey, newVal] = f(k, v);
-      Object.defineProperty(result, newKey, { value: newVal, writable: true, enumerable: true, configurable: true });
-    }
-    return result;
-  };
-  Rec2.updateIn = (path, f) => (data) => {
-    const updateNode = (obj, keys2) => {
-      const [head, ...tail] = keys2;
-      if (tail.length === 0) {
-        return { ...obj, [head]: f(obj?.[head]) };
-      }
-      const child = obj && typeof obj === "object" && head in obj ? obj[head] : {};
-      return { ...obj, [head]: updateNode(child, tail) };
-    };
-    return updateNode(data, path);
-  };
-  let traverse;
-  ((traverse2) => {
-    traverse2.Maybe = RecMaybe.traverse;
-    traverse2.Result = RecResult.traverse;
-  })(traverse = Rec2.traverse || (Rec2.traverse = {}));
-  let sequence;
-  ((sequence2) => {
-    sequence2.Maybe = RecMaybe.sequence;
-    sequence2.Result = RecResult.sequence;
-  })(sequence = Rec2.sequence || (Rec2.sequence = {}));
-  Rec2.NonEmpty = RecNonEmpty;
-})(Rec || (Rec = {}));
-
-// src/Data/Str.ts
-var StrNonEmpty;
-((StrNonEmpty2) => {
-  let from;
-  ((from2) => {
-    from2.String = (s) => s.length > 0 ? Maybe.make.some(s) : Maybe.make.none();
-  })(from = StrNonEmpty2.from || (StrNonEmpty2.from = {}));
-})(StrNonEmpty || (StrNonEmpty = {}));
-var Str;
-((Str2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (s) => s.length === 0;
-    is2.nonEmpty = (s) => s.length > 0;
-  })(is = Str2.is || (Str2.is = {}));
-  Str2.split = (separator) => (s) => s.split(separator);
-  Str2.trim = (s) => s.trim();
-  Str2.includes = (substring) => (s) => s.includes(substring);
-  Str2.replace = (pattern, replacement) => (s) => s.replace(pattern, replacement);
-  Str2.replaceAll = (pattern, replacement) => (s) => s.replaceAll(pattern, replacement);
-  Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
-  Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
-  Str2.toUpperCase = (s) => s.toUpperCase();
-  Str2.toLowerCase = (s) => s.toLowerCase();
-  Str2.capitalize = (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1);
-  Str2.lines = (s) => s.split(/\r?\n|\r/);
-  Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
-  Str2.isBlank = (s) => s.trim().length === 0;
-  Str2.length = (s) => s.length;
-  Str2.slice = (start, end) => (s) => s.slice(start, end);
-  Str2.padStart = (maxLength, fillString) => (s) => s.padStart(maxLength, fillString);
-  Str2.padEnd = (maxLength, fillString) => (s) => s.padEnd(maxLength, fillString);
-  Str2.parse = {
-    /**
-     * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
-     *
-     * @example
-     * ```ts
-     * Str.parse.int("42");   // Some(42)
-     * Str.parse.int("3.7");  // Some(3)
-     * Str.parse.int("abc");  // None
-     * ```
-     */
-    int: (s) => {
-      const n = parseInt(s, 10);
-      return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-    },
-    /**
-     * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
-     *
-     * @example
-     * ```ts
-     * Str.parse.float("3.14"); // Some(3.14)
-     * Str.parse.float("42");   // Some(42)
-     * Str.parse.float("abc");  // None
-     * ```
-     */
-    float: (s) => {
-      const n = parseFloat(s);
-      return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-    }
-  };
-  Str2.parseJson = (s) => {
-    try {
-      return Result.make.ok(JSON.parse(s));
-    } catch (error) {
-      return Result.make.err(error);
-    }
-  };
-  Str2.uncapitalize = (s) => s.length === 0 ? "" : s.charAt(0).toLowerCase() + s.slice(1);
-  Str2.truncate = (options) => (s) => {
-    const { length: targetLength, suffix = "..." } = options;
-    if (s.length <= targetLength) {
-      return s;
-    }
-    if (targetLength <= suffix.length) {
-      return suffix.slice(0, targetLength);
-    }
-    return s.slice(0, targetLength - suffix.length) + suffix;
-  };
-  Str2.NonEmpty = StrNonEmpty;
-})(Str || (Str = {}));
-
-// src/Data/Uniq.ts
-var UniqNonEmpty;
-((UniqNonEmpty2) => {
-  UniqNonEmpty2.singleton = (item) => new globalThis.Set([item]);
-  let from;
-  ((from2) => {
-    from2.Set = (s) => s.size > 0 ? Maybe.make.some(s) : Maybe.make.none();
-  })(from = UniqNonEmpty2.from || (UniqNonEmpty2.from = {}));
-  UniqNonEmpty2.reduce = (f) => (s) => to.Array(s).reduce(f);
-  UniqNonEmpty2.map = (f) => (s) => Uniq.map(f)(s);
-  let to;
-  ((to2) => {
-    to2.Array = (s) => Uniq.to.Array(s);
-  })(to = UniqNonEmpty2.to || (UniqNonEmpty2.to = {}));
-})(UniqNonEmpty || (UniqNonEmpty = {}));
-var Uniq;
-((Uniq2) => {
-  let is;
-  ((is2) => {
-    is2.empty = (s) => s.size === 0;
-    is2.nonEmpty = (s) => s.size > 0;
-  })(is = Uniq2.is || (Uniq2.is = {}));
-  Uniq2.empty = () => new globalThis.Set();
-  Uniq2.singleton = (item) => new globalThis.Set([item]);
-  let from;
-  ((from2) => {
-    from2.Array = (arr) => new globalThis.Set(arr);
-  })(from = Uniq2.from || (Uniq2.from = {}));
-  Uniq2.has = (item) => (s) => s.has(item);
-  Uniq2.size = (s) => s.size;
-  Uniq2.isSubsetOf = (other) => (s) => {
-    const set = s;
-    if (typeof set.isSubsetOf === "function") {
-      return set.isSubsetOf(other);
-    }
-    for (const item of s) {
-      if (!other.has(item)) {
-        return false;
-      }
-    }
-    return true;
-  };
-  Uniq2.insert = (item) => (s) => {
-    if (s.has(item)) {
-      return s;
-    }
-    const result = new globalThis.Set(s);
-    result.add(item);
-    return result;
-  };
-  Uniq2.remove = (item) => (s) => {
-    if (!s.has(item)) {
-      return s;
-    }
-    const result = new globalThis.Set(s);
-    result.delete(item);
-    return result;
-  };
-  Uniq2.map = (f) => (s) => {
-    const result = new globalThis.Set();
-    for (const item of s) {
-      result.add(f(item));
-    }
-    return result;
-  };
-  Uniq2.filter = (predicate) => (s) => {
-    const result = new globalThis.Set();
-    for (const item of s) {
-      if (predicate(item)) {
-        result.add(item);
-      }
-    }
-    return result;
-  };
-  Uniq2.union = (other) => (s) => {
-    const set = s;
-    if (typeof set.union === "function") {
-      return set.union(other);
-    }
-    const result = new globalThis.Set(s);
-    for (const item of other) {
-      result.add(item);
-    }
-    return result;
-  };
-  Uniq2.intersection = (other) => (s) => {
-    const set = s;
-    if (typeof set.intersection === "function") {
-      return set.intersection(other);
-    }
-    const result = new globalThis.Set();
-    for (const item of s) {
-      if (other.has(item)) {
-        result.add(item);
-      }
-    }
-    return result;
-  };
-  Uniq2.difference = (other) => (s) => {
-    const set = s;
-    if (typeof set.difference === "function") {
-      return set.difference(other);
-    }
-    const result = new globalThis.Set();
-    for (const item of s) {
-      if (!other.has(item)) {
-        result.add(item);
-      }
-    }
-    return result;
-  };
-  Uniq2.reduce = (init, f) => (s) => {
-    let acc = init;
-    for (const item of s) {
-      acc = f(acc, item);
-    }
-    return acc;
-  };
-  let to;
-  ((to2) => {
-    to2.Array = (s) => [...s];
-  })(to = Uniq2.to || (Uniq2.to = {}));
-  Uniq2.NonEmpty = UniqNonEmpty;
-})(Uniq || (Uniq = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import {
   Arr,
   BigNum,
   Dict,
@@ -2142,4 +7,16 @@ var Uniq;
   Rec,
   Str,
   Uniq
-});
+} from "./chunk-NIE7VVZU.js";
+import "./chunk-MFJXL6J2.js";
+import "./chunk-OIIOGDHK.js";
+export {
+  Arr,
+  BigNum,
+  Dict,
+  Json,
+  Num,
+  Rec,
+  Str,
+  Uniq
+};