@nlozgachev/pipelined 0.53.0 → 0.55.0

package/dist/data.cjs

@@ -0,0 +1,1612 @@
+"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;
+((Maybe2) => {
+  let make;
+  ((make2) => {
+    make2.some = (value) => ({ kind: "Some", value });
+    make2.none = () => _none;
+  })(make = Maybe2.make || (Maybe2.make = {}));
+  let is;
+  ((is2) => {
+    is2.some = (data) => data.kind === "Some";
+    is2.none = (data) => data.kind === "None";
+  })(is = Maybe2.is || (Maybe2.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 = Maybe2.to || (Maybe2.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 = Maybe2.from || (Maybe2.from = {}));
+  Maybe2.map = (f) => (data) => is.some(data) ? make.some(f(data.value)) : data;
+  Maybe2.chain = (f) => (data) => is.some(data) ? f(data.value) : data;
+  Maybe2.fold = (onNone, onSome) => (data) => is.some(data) ? onSome(data.value) : onNone();
+  Maybe2.match = (cases) => (data) => is.some(data) ? cases.some(data.value) : cases.none();
+  Maybe2.getOrElse = (defaultValue) => (data) => is.some(data) ? data.value : defaultValue();
+  Maybe2.tap = (f) => (data) => {
+    if (is.some(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Maybe2.filter = (predicate) => (data) => is.some(data) ? predicate(data.value) ? data : make.none() : data;
+  Maybe2.recover = (fallback) => (data) => is.some(data) ? data : fallback();
+  Maybe2.ap = (arg) => (data) => is.some(data) && is.some(arg) ? make.some(data.value(arg.value)) : make.none();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Maybe2.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);
+  };
+  Maybe2.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/Core/Result.ts
+var Result;
+((Result2) => {
+  let make;
+  ((make2) => {
+    make2.ok = (value) => ({ kind: "Ok", value });
+    make2.err = (e) => ({ kind: "Err", error: e });
+  })(make = Result2.make || (Result2.make = {}));
+  let is;
+  ((is2) => {
+    is2.ok = (data) => data.kind === "Ok";
+    is2.err = (data) => data.kind === "Err";
+  })(is = Result2.is || (Result2.is = {}));
+  Result2.tryCatch = (f, options) => {
+    try {
+      return make.ok(f());
+    } catch (error) {
+      return make.err(options.onError(error));
+    }
+  };
+  Result2.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
+  Result2.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
+  Result2.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
+  Result2.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
+  Result2.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result2.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
+  Result2.tap = (f) => (data) => {
+    if (is.ok(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Result2.tapError = (f) => (data) => {
+    if (is.err(data)) {
+      f(data.error);
+    }
+    return data;
+  };
+  let from;
+  ((from2) => {
+    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.ok(a) : make.err(onFalse(a));
+    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.err(onNull()) : make.ok(value);
+    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.err(onNone()) : make.ok(maybe.value);
+    from2.Validation = (combineErrors) => (val) => Validation.is.passed(val) ? make.ok(val.value) : make.err(combineErrors(val.errors));
+  })(from = Result2.from || (Result2.from = {}));
+  Result2.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
+  Result2.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 = Result2.to || (Result2.to = {}));
+  Result2.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();
+  Result2.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Result2.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);
+  };
+  Result2.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
+  Result2.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
+})(Result || (Result = {}));
+
+// src/internal/InternalTypes.ts
+var isNonEmptyArr = (list) => list.length > 0;
+
+// 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 Result2(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 = Result2;
+    to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+  })(to = Validation2.to || (Validation2.to = {}));
+  Validation2.product = (first, second) => {
+    if (is.passed(first)) {
+      return is.passed(second) ? make.passed([first.value, second.value]) : make.failedAll(second.errors);
+    }
+    return is.passed(second) ? make.failedAll(first.errors) : make.failedAll([...first.errors, ...second.errors]);
+  };
+  Validation2.productAll = (data) => {
+    const values = [];
+    const errors = [];
+    for (const v of data) {
+      if (is.passed(v)) {
+        values.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
+    }
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(values);
+  };
+  Validation2.struct = (fields) => {
+    const record = {};
+    const errors = [];
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const val = fields[key];
+        if (is.passed(val)) {
+          record[key] = val.value;
+        } else {
+          errors.push(...val.errors);
+        }
+      }
+    }
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
+  };
+})(Validation || (Validation = {}));
+
+// src/Data/Arr.ts
+var ArrMaybe;
+((ArrMaybe2) => {
+  ArrMaybe2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "None") {
+        return Maybe.make.none();
+      }
+      result[i] = mapped.value;
+    }
+    return Maybe.make.some(result);
+  };
+  ArrMaybe2.sequence = (data) => (0, ArrMaybe2.traverse)((a) => a)(data);
+})(ArrMaybe || (ArrMaybe = {}));
+var ArrResult;
+((ArrResult2) => {
+  ArrResult2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Err") {
+        return mapped;
+      }
+      result[i] = mapped.value;
+    }
+    return Result.make.ok(result);
+  };
+  ArrResult2.sequence = (data) => (0, ArrResult2.traverse)((a) => a)(data);
+})(ArrResult || (ArrResult = {}));
+var ArrTaskResult;
+((ArrTaskResult2) => {
+  ArrTaskResult2.traverse = (f) => (data) => () => Deferred.from.Promise((async () => {
+    const result = [];
+    for (const a of data) {
+      const r = await Deferred.to.Promise(f(a)());
+      if (Result.is.err(r)) {
+        return r;
+      }
+      result.push(r.value);
+    }
+    return Result.make.ok(result);
+  })());
+  ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
+})(ArrTaskResult || (ArrTaskResult = {}));
+var ArrTask;
+((ArrTask2) => {
+  ArrTask2.traverse = (f) => (data) => () => Deferred.from.Promise(Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
+  ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
+  ArrTask2.Result = ArrTaskResult;
+})(ArrTask || (ArrTask = {}));
+var ArrNonEmpty;
+((ArrNonEmpty2) => {
+  ArrNonEmpty2.singleton = (value) => [value];
+  let from;
+  ((from2) => {
+    from2.Array = (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none();
+  })(from = ArrNonEmpty2.from || (ArrNonEmpty2.from = {}));
+  ArrNonEmpty2.head = (data) => data[0];
+  ArrNonEmpty2.last = (data) => data[data.length - 1];
+  ArrNonEmpty2.tail = (data) => data.slice(1);
+  ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
+  ArrNonEmpty2.map = (f) => (data) => Arr.map(f)(data);
+  ArrNonEmpty2.mapWithIndex = (f) => (data) => Arr.mapWithIndex(f)(data);
+  ArrNonEmpty2.intersperse = (sep) => (data) => Arr.intersperse(sep)(data);
+  ArrNonEmpty2.concat = (other) => (data) => Arr.concat(other)(data);
+  ArrNonEmpty2.reverse = (data) => Arr.reverse(data);
+})(ArrNonEmpty || (ArrNonEmpty = {}));
+var Arr;
+((Arr2) => {
+  Arr2.head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
+  Arr2.last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
+  Arr2.tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
+  Arr2.init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
+  Arr2.findFirst = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
+  };
+  Arr2.findLast = (predicate) => (data) => {
+    for (let i = data.length - 1; i >= 0; i--) {
+      if (predicate(data[i])) {
+        return Maybe.make.some(data[i]);
+      }
+    }
+    return Maybe.make.none();
+  };
+  Arr2.findIndex = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.none();
+  };
+  Arr2.map = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      result[i] = f(data[i]);
+    }
+    return result;
+  };
+  Arr2.mapWithIndex = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      result[i] = f(i, data[i]);
+    }
+    return result;
+  };
+  Arr2.filter = (predicate) => (data) => {
+    const n = data.length;
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      if (predicate(data[i])) {
+        result.push(data[i]);
+      }
+    }
+    return result;
+  };
+  Arr2.filterMap = (f) => (data) => {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Some") {
+        result.push(mapped.value);
+      }
+    }
+    return result;
+  };
+  Arr2.partition = (predicate) => (data) => {
+    const pass = [];
+    const fail = [];
+    for (const a of data) {
+      (predicate(a) ? pass : fail).push(a);
+    }
+    return [pass, fail];
+  };
+  Arr2.compact = (data) => {
+    const result = [];
+    for (const item of data) {
+      if (item.kind === "Some") {
+        result.push(item.value);
+      }
+    }
+    return result;
+  };
+  Arr2.separate = (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      if (item.kind === "Ok") {
+        successes.push(item.value);
+      } else {
+        errors.push(item.error);
+      }
+    }
+    return [errors, successes];
+  };
+  Arr2.partitionMap = (f) => (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      const mapped = f(item);
+      if (mapped.kind === "Ok") {
+        successes.push(mapped.value);
+      } else {
+        errors.push(mapped.error);
+      }
+    }
+    return [errors, successes];
+  };
+  Arr2.groupBy = (f) => (data) => {
+    const result = {};
+    for (const a of data) {
+      const key = f(a);
+      if (!result[key]) {
+        result[key] = [];
+      }
+      result[key].push(a);
+    }
+    return result;
+  };
+  Arr2.uniq = (data) => [...new Set(data)];
+  Arr2.uniqBy = (f) => (data) => {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const a of data) {
+      const key = f(a);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(a);
+      }
+    }
+    return result;
+  };
+  Arr2.uniqWith = (eq) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!result.some((x) => eq(x, a))) {
+        result.push(a);
+      }
+    }
+    return result;
+  };
+  Arr2.sortBy = (compare) => (data) => {
+    const arr = data;
+    if (typeof arr.toSorted === "function") {
+      return arr.toSorted(compare);
+    }
+    return [...data].toSorted(compare);
+  };
+  Arr2.sortWith = (ord) => (data) => {
+    const arr = data;
+    if (typeof arr.toSorted === "function") {
+      return arr.toSorted(ord);
+    }
+    return [...data].sort(ord);
+  };
+  Arr2.zip = (other) => (data) => {
+    const len = Math.min(data.length, other.length);
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = [data[i], other[i]];
+    }
+    return result;
+  };
+  Arr2.zipWith = (f) => (other) => (data) => {
+    const len = Math.min(data.length, other.length);
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = f(data[i], other[i]);
+    }
+    return result;
+  };
+  Arr2.intersperse = (sep) => (data) => {
+    if (data.length <= 1) {
+      return data;
+    }
+    const result = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      result.push(sep, data[i]);
+    }
+    return result;
+  };
+  Arr2.concat = (other) => (data) => [...data, ...other];
+  Arr2.chunksOf = (n) => (data) => {
+    if (n <= 0) {
+      return [];
+    }
+    const result = [];
+    for (let i = 0; i < data.length; i += n) {
+      result.push(data.slice(i, i + n));
+    }
+    return result;
+  };
+  Arr2.flatten = (data) => {
+    let totalLen = 0;
+    const outerLen = data.length;
+    for (let i = 0; i < outerLen; i++) {
+      totalLen += data[i].length;
+    }
+    const result = new Array(totalLen);
+    let idx = 0;
+    for (let i = 0; i < outerLen; i++) {
+      const chunk = data[i];
+      const innerLen = chunk.length;
+      for (let j = 0; j < innerLen; j++) {
+        result[idx++] = chunk[j];
+      }
+    }
+    return result;
+  };
+  Arr2.flatMap = (f) => (data) => {
+    const n = data.length;
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      const chunk = f(data[i]);
+      const m = chunk.length;
+      for (let j = 0; j < m; j++) {
+        result.push(chunk[j]);
+      }
+    }
+    return result;
+  };
+  Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
+  const _traverseTask = Object.assign((f) => ArrTask.traverse(f), {
+    Result: ArrTaskResult.traverse
+  });
+  const _sequenceTask = Object.assign((data) => ArrTask.sequence(data), {
+    Result: ArrTaskResult.sequence
+  });
+  let traverse;
+  ((traverse2) => {
+    traverse2.Maybe = ArrMaybe.traverse;
+    traverse2.Result = ArrResult.traverse;
+    traverse2.Task = _traverseTask;
+  })(traverse = Arr2.traverse || (Arr2.traverse = {}));
+  let sequence;
+  ((sequence2) => {
+    sequence2.Maybe = ArrMaybe.sequence;
+    sequence2.Result = ArrResult.sequence;
+    sequence2.Task = _sequenceTask;
+  })(sequence = Arr2.sequence || (Arr2.sequence = {}));
+  let is;
+  ((is2) => {
+    is2.empty = (data) => data.length === 0;
+    is2.nonEmpty = (data) => isNonEmptyArr(data);
+  })(is = Arr2.is || (Arr2.is = {}));
+  Arr2.prepend = (value) => (data) => [value, ...data];
+  Arr2.append = (value) => (data) => [...data, value];
+  Arr2.size = (data) => data.length;
+  Arr2.some = (predicate) => (data) => {
+    const n = data.length;
+    for (let i = 0; i < n; i++) {
+      if (predicate(data[i])) {
+        return true;
+      }
+    }
+    return false;
+  };
+  Arr2.every = (predicate) => (data) => {
+    const n = data.length;
+    for (let i = 0; i < n; i++) {
+      if (!predicate(data[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
+  Arr2.reverse = (data) => [...data].toReversed();
+  Arr2.insertAt = (index, item) => (data) => {
+    const i = Math.max(0, Math.min(index, data.length));
+    const arr = data;
+    if (typeof arr.toSpliced === "function") {
+      return arr.toSpliced(i, 0, item);
+    }
+    const result = [...data];
+    result.splice(i, 0, item);
+    return result;
+  };
+  Arr2.removeAt = (index) => (data) => {
+    if (index < 0 || index >= data.length) {
+      return data;
+    }
+    const arr = data;
+    if (typeof arr.toSpliced === "function") {
+      return arr.toSpliced(index, 1);
+    }
+    const result = [...data];
+    result.splice(index, 1);
+    return result;
+  };
+  Arr2.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
+  Arr2.drop = (n) => (data) => data.slice(n);
+  Arr2.takeWhile = (predicate) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!predicate(a)) {
+        break;
+      }
+      result.push(a);
+    }
+    return result;
+  };
+  Arr2.dropWhile = (predicate) => (data) => {
+    let i = 0;
+    while (i < data.length && predicate(data[i])) {
+      i++;
+    }
+    return data.slice(i);
+  };
+  Arr2.scan = (initial, f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    let acc = initial;
+    for (let i = 0; i < n; i++) {
+      acc = f(acc, data[i]);
+      result[i] = acc;
+    }
+    return result;
+  };
+  Arr2.splitAt = (index) => (data) => {
+    const i = Math.max(0, index);
+    return [data.slice(0, i), data.slice(i)];
+  };
+  Arr2.partitionMaybe = (f) => (data) => {
+    const failures = [];
+    const successes = [];
+    for (let i = 0; i < data.length; i++) {
+      const res = f(data[i]);
+      if (res.kind === "Some") {
+        successes.push(res.value);
+      } else {
+        failures.push(data[i]);
+      }
+    }
+    return [failures, successes];
+  };
+  Arr2.at = (index) => (data) => {
+    const targetIndex = index < 0 ? data.length + index : index;
+    if (targetIndex < 0 || targetIndex >= data.length) {
+      return Maybe.make.none();
+    }
+    return Maybe.make.some(data[targetIndex]);
+  };
+  Arr2.findMap = (f) => (data) => {
+    for (let i = 0; i < data.length; i++) {
+      const res = f(data[i]);
+      if (res.kind === "Some") {
+        return res;
+      }
+    }
+    return Maybe.make.none();
+  };
+  Arr2.indexBy = (keyFn) => (data) => {
+    const map2 = new globalThis.Map();
+    for (let i = 0; i < data.length; i++) {
+      map2.set(keyFn(data[i]), data[i]);
+    }
+    return map2;
+  };
+  Arr2.frequencies = (data) => {
+    const map2 = new globalThis.Map();
+    for (let i = 0; i < data.length; i++) {
+      const item = data[i];
+      map2.set(item, (map2.get(item) ?? 0) + 1);
+    }
+    return map2;
+  };
+  Arr2.chunkBy = (keyFn) => (data) => {
+    if (data.length === 0) {
+      return [];
+    }
+    const result = [];
+    let currentChunk = [data[0]];
+    let currentKey = keyFn(data[0]);
+    for (let i = 1; i < data.length; i++) {
+      const item = data[i];
+      const key = keyFn(item);
+      if (Object.is(key, currentKey)) {
+        currentChunk.push(item);
+      } else {
+        result.push(currentChunk);
+        currentChunk = [item];
+        currentKey = key;
+      }
+    }
+    result.push(currentChunk);
+    return result;
+  };
+  Arr2.dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
+    if (data.length === 0) {
+      return [];
+    }
+    const result = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      if (!eq(data[i], result[result.length - 1])) {
+        result.push(data[i]);
+      }
+    }
+    return result;
+  };
+  Arr2.windowed = (size2, options) => (data) => {
+    const step = options?.step ?? 1;
+    if (size2 <= 0 || step <= 0 || data.length < size2) {
+      return [];
+    }
+    const result = [];
+    for (let i = 0; i <= data.length - size2; i += step) {
+      result.push(data.slice(i, i + size2));
+    }
+    return result;
+  };
+  Arr2.unfold = (initial, f) => {
+    const result = [];
+    let currentState = initial;
+    while (true) {
+      const next = f(currentState);
+      if (next.kind === "None") {
+        break;
+      }
+      const [item, nextState] = next.value;
+      result.push(item);
+      currentState = nextState;
+    }
+    return result;
+  };
+  Arr2.NonEmpty = ArrNonEmpty;
+})(Arr || (Arr = {}));
+
+// src/Data/BigNum.ts
+var BigNum;
+((BigNum2) => {
+  let from;
+  ((from2) => {
+    from2.string = (s) => {
+      try {
+        if (s.trim() === "") {
+          return Maybe.make.none();
+        }
+        return Maybe.make.some(BigInt(s));
+      } catch {
+        return Maybe.make.none();
+      }
+    };
+    from2.number = (n) => {
+      if (!Number.isInteger(n) || n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
+        return Maybe.make.none();
+      }
+      return Maybe.make.some(BigInt(n));
+    };
+  })(from = BigNum2.from || (BigNum2.from = {}));
+  let to;
+  ((to2) => {
+    to2.number = (b) => {
+      if (b < BigInt(Number.MIN_SAFE_INTEGER) || b > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Maybe.make.none();
+      }
+      return Maybe.make.some(Number(b));
+    };
+  })(to = BigNum2.to || (BigNum2.to = {}));
+  BigNum2.add = (b) => (a) => a + b;
+  BigNum2.sub = (b) => (a) => a - b;
+  BigNum2.mul = (b) => (a) => a * b;
+  BigNum2.div = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a / b);
+  BigNum2.mod = (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a % b);
+  BigNum2.clamp = (min2, max2) => (a) => a < min2 ? min2 : a > max2 ? max2 : a;
+  BigNum2.inRange = (start, end) => (a) => a >= start && a < end;
+  BigNum2.abs = (a) => a < 0n ? -a : a;
+  BigNum2.min = (b) => (a) => a < b ? a : b;
+  BigNum2.max = (b) => (a) => a > b ? a : b;
+})(BigNum || (BigNum = {}));
+
+// src/Data/Dict.ts
+var DictNonEmpty;
+((DictNonEmpty2) => {
+  DictNonEmpty2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  let from;
+  ((from2) => {
+    from2.Map = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
+  })(from = DictNonEmpty2.from || (DictNonEmpty2.from = {}));
+  DictNonEmpty2.keys = (m) => Dict.keys(m);
+  DictNonEmpty2.values = (m) => Dict.values(m);
+  DictNonEmpty2.entries = (m) => Dict.entries(m);
+  DictNonEmpty2.reduce = (f) => (m) => (0, DictNonEmpty2.values)(m).reduce(f);
+  DictNonEmpty2.map = (f) => (m) => Dict.map(f)(m);
+  DictNonEmpty2.mapWithKey = (f) => (m) => Dict.mapWithKey(f)(m);
+})(DictNonEmpty || (DictNonEmpty = {}));
+var Dict;
+((Dict2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (m) => m.size === 0;
+    is2.nonEmpty = (m) => m.size > 0;
+  })(is = Dict2.is || (Dict2.is = {}));
+  Dict2.empty = () => new globalThis.Map();
+  Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  let from;
+  ((from2) => {
+    from2.entries = (entries3) => new globalThis.Map(entries3);
+    from2.Record = (rec) => new globalThis.Map(Object.entries(rec));
+  })(from = Dict2.from || (Dict2.from = {}));
+  Dict2.groupBy = (keyFn) => (items) => {
+    const result = new globalThis.Map();
+    for (const item of items) {
+      const key = keyFn(item);
+      const arr = result.get(key);
+      if (arr !== void 0) {
+        arr.push(item);
+      } else {
+        result.set(key, [item]);
+      }
+    }
+    return result;
+  };
+  Dict2.has = (key) => (m) => m.has(key);
+  Dict2.lookup = (key) => (m) => m.has(key) ? Maybe.make.some(m.get(key)) : Maybe.make.none();
+  Dict2.size = (m) => m.size;
+  Dict2.keys = (m) => [...m.keys()];
+  Dict2.values = (m) => [...m.values()];
+  Dict2.entries = (m) => [...m.entries()];
+  Dict2.insert = (key, value) => (m) => {
+    const result = new globalThis.Map(m);
+    result.set(key, value);
+    return result;
+  };
+  Dict2.remove = (key) => (m) => {
+    if (!m.has(key)) {
+      return m;
+    }
+    const result = new globalThis.Map(m);
+    result.delete(key);
+    return result;
+  };
+  Dict2.upsert = (key, f) => (m) => {
+    const result = new globalThis.Map(m);
+    result.set(key, f((0, Dict2.lookup)(key)(m)));
+    return result;
+  };
+  Dict2.map = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      result.set(k, f(v));
+    }
+    return result;
+  };
+  Dict2.mapWithKey = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      result.set(k, f(k, v));
+    }
+    return result;
+  };
+  Dict2.filter = (predicate) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (predicate(v)) {
+        result.set(k, v);
+      }
+    }
+    return result;
+  };
+  Dict2.filterWithKey = (predicate) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (predicate(k, v)) {
+        result.set(k, v);
+      }
+    }
+    return result;
+  };
+  Dict2.compact = (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (v.kind === "Some") {
+        result.set(k, v.value);
+      }
+    }
+    return result;
+  };
+  Dict2.filterMap = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [key, value] of m) {
+      const mapped = f(value);
+      if (mapped.kind === "Some") {
+        result.set(key, mapped.value);
+      }
+    }
+    return result;
+  };
+  Dict2.union = (other) => (m) => {
+    const result = new globalThis.Map(m);
+    for (const [k, v] of other) {
+      result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.intersection = (other) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (other.has(k)) {
+        result.set(k, v);
+      }
+    }
+    return result;
+  };
+  Dict2.difference = (other) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (!other.has(k)) {
+        result.set(k, v);
+      }
+    }
+    return result;
+  };
+  Dict2.reduce = (init, f) => (m) => {
+    let acc = init;
+    for (const v of m.values()) {
+      acc = f(acc, v);
+    }
+    return acc;
+  };
+  Dict2.reduceWithKey = (init, f) => (m) => {
+    let acc = init;
+    for (const [k, v] of m) {
+      acc = f(acc, v, k);
+    }
+    return acc;
+  };
+  function mergeWith(combine) {
+    return (arg1, arg2) => {
+      if (arg2 !== void 0) {
+        const first = arg1;
+        const second2 = arg2;
+        const res = new globalThis.Map(first);
+        for (const [k, v] of second2) {
+          if (res.has(k)) {
+            res.set(k, combine(res.get(k), v));
+          } else {
+            res.set(k, v);
+          }
+        }
+        return res;
+      }
+      const second = arg1;
+      return (first) => {
+        const res = new globalThis.Map(first);
+        for (const [k, v] of second) {
+          if (res.has(k)) {
+            res.set(k, combine(res.get(k), v));
+          } else {
+            res.set(k, v);
+          }
+        }
+        return res;
+      };
+    };
+  }
+  Dict2.mergeWith = mergeWith;
+  let to;
+  ((to2) => {
+    to2.Record = (m) => Object.fromEntries(m);
+  })(to = Dict2.to || (Dict2.to = {}));
+  Dict2.mapEntries = (f) => (data) => {
+    const res = new globalThis.Map();
+    for (const [k, v] of data) {
+      const [nk, nv] = f(k, v);
+      res.set(nk, nv);
+    }
+    return res;
+  };
+  Dict2.mapKeys = (f) => (data) => {
+    const res = new globalThis.Map();
+    for (const [k, v] of data) {
+      res.set(f(k), v);
+    }
+    return res;
+  };
+  Dict2.NonEmpty = DictNonEmpty;
+})(Dict || (Dict = {}));
+
+// src/Data/Json.ts
+var isSyntaxError = (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 = {
+  Arr,
+  BigNum,
+  Dict,
+  Json,
+  Num,
+  Rec,
+  Str,
+  Uniq
+});