@nlozgachev/pipelined 0.46.0 → 0.48.0

package/dist/index.js

@@ -21,12 +21,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Arr: () => Arr,
+  BigNum: () => BigNum,
   Brand: () => Brand,
   Combinable: () => Combinable,
   Deferred: () => Deferred,
   Dict: () => Dict,
   Duration: () => Duration,
   Equality: () => Equality,
+  Json: () => Json,
   Lazy: () => Lazy,
   Lens: () => Lens,
   Logged: () => Logged,
@@ -42,6 +44,7 @@ __export(src_exports, {
   RemoteData: () => RemoteData,
   Resource: () => Resource,
   Result: () => Result,
+  RetryPolicy: () => RetryPolicy,
   State: () => State,
   Str: () => Str,
   Task: () => Task,
@@ -77,9 +80,11 @@ __export(src_exports, {
   or: () => or,
   pipe: () => pipe,
   tap: () => tap,
+  tuple: () => tuple,
   uncurry: () => uncurry,
   uncurry3: () => uncurry3,
-  uncurry4: () => uncurry4
+  uncurry4: () => uncurry4,
+  untuple: () => untuple
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -281,6 +286,8 @@ var once = (f) => {
   };
 };
 var defaultTo = (fallback) => (a) => a === null || a === void 0 ? fallback : a;
+var tuple = (f) => (args) => f(...args);
+var untuple = (f) => (...args) => f(args);
 
 // src/Composition/juxt.ts
 function juxt(fns) {
@@ -288,8 +295,9 @@ function juxt(fns) {
 }
 
 // src/Composition/memoize.ts
-var memoize = (f, keyFn = (a) => a) => {
+var memoize = (f, options) => {
   const cache = /* @__PURE__ */ new Map();
+  const keyFn = options?.key ?? ((a) => a);
   return (a) => {
     const key = keyFn(a);
     if (cache.has(key)) {
@@ -410,6 +418,29 @@ var Brand;
   Brand2.unwrap = (branded) => branded;
 })(Brand || (Brand = {}));
 
+// src/Types/RetryPolicy.ts
+var RetryPolicy;
+((RetryPolicy2) => {
+  RetryPolicy2.constant = (options) => ({
+    attempts: Math.max(1, options.attempts),
+    getDelay: () => options.delay
+  });
+  RetryPolicy2.exponential = (options) => {
+    const attempts = Math.max(1, options.attempts);
+    const initialMs = Duration.to.milliseconds(options.initial);
+    const factor = options.factor ?? 2;
+    const jitter = options.jitter ?? false;
+    return {
+      attempts,
+      getDelay: (attempt) => {
+        const rawMs = initialMs * factor ** Math.max(0, attempt - 1);
+        const finalMs = jitter ? Math.random() * rawMs : rawMs;
+        return Duration.milliseconds(finalMs);
+      }
+    };
+  };
+})(RetryPolicy || (RetryPolicy = {}));
+
 // src/Types/Duration.ts
 var Duration;
 ((Duration2) => {
@@ -540,6 +571,26 @@ var Combinable;
     combine: (b) => (a) => Maybe.is.none(a) ? b : Maybe.is.none(b) ? a : Maybe.make.some(inner.combine(b.value)(a.value))
   });
   Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
+  Combinable2.struct = (fields) => {
+    const empty = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        empty[key] = fields[key].empty;
+      }
+    }
+    return {
+      empty,
+      combine: (b) => (a) => {
+        const result = {};
+        for (const key in fields) {
+          if (Object.hasOwn(fields, key)) {
+            result[key] = fields[key].combine(b[key])(a[key]);
+          }
+        }
+        return result;
+      }
+    };
+  };
 })(Combinable || (Combinable = {}));
 
 // src/Core/Deferred.ts
@@ -556,6 +607,8 @@ var Deferred;
   ((to2) => {
     to2.Promise = (d) => new globalThis.Promise((resolve) => d.then(resolve));
   })(to = Deferred2.to || (Deferred2.to = {}));
+  Deferred2.all = (deferreds) => from.Promise(globalThis.Promise.all(deferreds.map((d) => to.Promise(d))));
+  Deferred2.race = (deferreds) => from.Promise(globalThis.Promise.race(deferreds.map((d) => to.Promise(d))));
 })(Deferred || (Deferred = {}));
 
 // src/Core/Equality.ts
@@ -568,6 +621,27 @@ var Equality;
   Equality3.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
   Equality3.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
   Equality3.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
+  Equality3.struct = (fields) => (a, b) => {
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        if (!fields[key](a[key], b[key])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+  Equality3.tuple = (...equalities) => (a, b) => {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < equalities.length; i++) {
+      if (!equalities[i](a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
 })(Equality || (Equality = {}));
 
 // src/Core/Lazy.ts
@@ -647,6 +721,10 @@ var Logged;
   Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
     (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  Logged2.focus = (lens) => (f) => (data) => ({
+    value: lens.set(f(lens.get(data.value)))(data.value),
+    log: data.log
+  });
 })(Logged || (Logged = {}));
 
 // src/Core/Maybe.ts
@@ -706,6 +784,7 @@ var Maybe;
     }
     return make.some(result);
   };
+  Maybe3.transposeResult = (data) => is.none(data) ? Result.make.ok(make.none()) : Result.is.ok(data.value) ? Result.make.ok(make.some(data.value.value)) : Result.make.err(data.value.error);
 })(Maybe || (Maybe = {}));
 
 // src/internal/Op.util.ts
@@ -1857,6 +1936,25 @@ var Ordering;
     return r !== 0 ? r : ord2(a, b);
   };
   Ordering3.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
+  Ordering3.byFields = (orderings) => (a, b) => {
+    for (let i = 0; i < orderings.length; i++) {
+      const res = orderings[i](a, b);
+      if (res !== 0) {
+        return res;
+      }
+    }
+    return 0;
+  };
+  Ordering3.tuple = (...orderings) => (a, b) => {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+      const res = orderings[i](a[i], b[i]);
+      if (res !== 0) {
+        return res;
+      }
+    }
+    return a.length - b.length;
+  };
 })(Ordering || (Ordering = {}));
 
 // src/Core/Predicate.ts
@@ -1872,6 +1970,15 @@ var Predicate;
   ((from2) => {
     from2.Refinement = (r) => r;
   })(from = Predicate2.from || (Predicate2.from = {}));
+  Predicate2.match = (branches, fallback) => (a) => {
+    for (let i = 0; i < branches.length; i++) {
+      const [p, h] = branches[i];
+      if (p(a)) {
+        return h(a);
+      }
+    }
+    return fallback(a);
+  };
 })(Predicate || (Predicate = {}));
 
 // src/Core/Reader.ts
@@ -2071,11 +2178,11 @@ var Result;
     is2.ok = (data) => data.kind === "Ok";
     is2.err = (data) => data.kind === "Err";
   })(is = Result4.is || (Result4.is = {}));
-  Result4.tryCatch = (f, onError) => {
+  Result4.tryCatch = (f, options) => {
     try {
       return make.ok(f());
     } catch (error) {
-      return make.err(onError(error));
+      return make.err(options.onError(error));
     }
   };
   Result4.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
@@ -2101,20 +2208,23 @@ var Result;
     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, onError) => (...args) => {
+    from2.throwable = (f, options) => (...args) => {
       try {
         return make.ok(f(...args));
       } catch (error) {
-        return make.err(onError(error));
+        return make.err(options.onError(error));
       }
     };
+    from2.Validation = (combineErrors) => (val) => Validation.is.passed(val) ? make.ok(val.value) : make.err(combineErrors(val.errors));
   })(from = Result4.from || (Result4.from = {}));
   Result4.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
   Result4.recoverUnless = (isBlocked, fallback) => (data) => is.err(data) && !isBlocked(data.error) ? fallback() : data;
   let to;
   ((to2) => {
     to2.Maybe = (data) => is.ok(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+    to2.Validation = (data) => Validation.from.Result(data);
   })(to = Result4.to || (Result4.to = {}));
+  Result4.transposeMaybe = (data) => is.err(data) ? Maybe.make.some(data) : Maybe.is.some(data.value) ? Maybe.make.some(make.ok(data.value.value)) : Maybe.make.none();
   Result4.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
   Result4.bindTo = (key) => (data) => (0, Result4.map)((a) => ({ [key]: a }))(data);
   Result4.bind = (key, f) => (data) => (0, Result4.chain)(
@@ -2133,6 +2243,8 @@ var Result;
     }
     return make.ok(result);
   };
+  Result4.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
+  Result4.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
 })(Result || (Result = {}));
 
 // src/Core/State.ts
@@ -2168,13 +2280,23 @@ var State;
   State2.bind = (key, f) => (data) => (0, State2.chain)(
     (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  State2.focus = (lens) => (stateOp) => (s) => {
+    const subState = lens.get(s);
+    const [b, newSubState] = stateOp(subState);
+    return [b, lens.set(newSubState)(s)];
+  };
 })(State || (State = {}));
 
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
-  TaskMaybe2.some = (value) => Task.resolve(Maybe.make.some(value));
-  TaskMaybe2.none = () => Task.resolve(Maybe.make.none());
+  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);
@@ -2230,19 +2352,28 @@ var TaskMaybe;
 // src/Core/TaskResult.ts
 var TaskResult;
 ((TaskResult2) => {
-  TaskResult2.ok = (value) => Task.resolve(Result.make.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.make.err(error));
+  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, onError) => (...args) => Task.from.Promise(
-      () => f(...args).then(Result.make.ok).catch((error) => Result.make.err(onError(error)))
+    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 = {}));
-  TaskResult2.tryCatch = (f, onError) => Task.from.Promise(
-    (signal) => Promise.resolve(f(signal)).then(Result.make.ok).catch((error) => Result.make.err(onError(error)))
+  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);
@@ -2282,6 +2413,60 @@ var TaskResult;
       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
@@ -2290,9 +2475,15 @@ var isNonEmptyArr = (list) => list.length > 0;
 // src/Core/TaskValidation.ts
 var TaskValidation;
 ((TaskValidation2) => {
-  TaskValidation2.passed = (value) => Task.resolve(Validation.make.passed(value));
-  TaskValidation2.failed = (error) => Task.resolve(Validation.make.failed(error));
-  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
+  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);
@@ -2510,7 +2701,8 @@ var Task;
     }
     return results;
   });
-  Task2.timeout = (duration, onTimeout) => (task) => from.Promise((outerSignal) => {
+  Task2.timeout = (options) => (task) => from.Promise((outerSignal) => {
+    const { duration, onTimeout } = options;
     const controller = new AbortController();
     let timerId;
     let cleanUp = () => {
@@ -2567,6 +2759,30 @@ var Task;
   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;
@@ -2673,23 +2889,23 @@ var Tuple;
     from2.pair = (first2, second2) => [first2, second2];
     from2.array = (arr) => arr;
   })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
+  Tuple2.first = (tuple2) => tuple2[0];
+  Tuple2.second = (tuple2) => tuple2[1];
+  Tuple2.mapFirst = (f) => (tuple2) => [f(tuple2[0]), tuple2[1]];
+  Tuple2.mapSecond = (f) => (tuple2) => [tuple2[0], f(tuple2[1])];
+  Tuple2.mapBoth = (onFirst, onSecond) => (tuple2) => [
+    onFirst(tuple2[0]),
+    onSecond(tuple2[1])
   ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
+  Tuple2.fold = (f) => (tuple2) => f(tuple2[0], tuple2[1]);
+  Tuple2.swap = (tuple2) => [tuple2[1], tuple2[0]];
   let to;
   ((to2) => {
-    to2.Array = (tuple) => [...tuple];
+    to2.Array = (tuple2) => [...tuple2];
   })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
+  Tuple2.tap = (f) => (tuple2) => {
+    f(tuple2[0], tuple2[1]);
+    return tuple2;
   };
 })(Tuple || (Tuple = {}));
 
@@ -2707,6 +2923,13 @@ var Validation;
     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));
@@ -2722,6 +2945,12 @@ var Validation;
     }
     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();
@@ -2741,7 +2970,14 @@ var Validation;
   Validation2.recoverUnless = (isBlocked, fallback) => (data) => is.failed(data) && !data.errors.some(isBlocked) ? fallback() : data;
   let to;
   ((to2) => {
-    to2.Result = (data) => is.passed(data) ? Result.make.ok(data.value) : Result.make.err(data.errors);
+    function Result4(arg) {
+      if (typeof arg === "function") {
+        const combine = arg;
+        return (val) => is.passed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
+      }
+      return is.passed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
+    }
+    to2.Result = Result4;
     to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
   })(to = Validation2.to || (Validation2.to = {}));
   Validation2.product = (first, second) => {
@@ -3164,9 +3400,154 @@ var Arr;
     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) => {
@@ -3323,16 +3704,86 @@ var Dict;
     }
     return acc;
   };
+  function mergeWith(combine) {
+    return (arg1, arg2) => {
+      if (arg2 !== void 0) {
+        const first = arg1;
+        const second2 = arg2;
+        const res = new globalThis.Map(first);
+        for (const [k, v] of second2) {
+          if (res.has(k)) {
+            res.set(k, combine(res.get(k), v));
+          } else {
+            res.set(k, v);
+          }
+        }
+        return res;
+      }
+      const second = arg1;
+      return (first) => {
+        const res = new globalThis.Map(first);
+        for (const [k, v] of second) {
+          if (res.has(k)) {
+            res.set(k, combine(res.get(k), v));
+          } else {
+            res.set(k, v);
+          }
+        }
+        return res;
+      };
+    };
+  }
+  Dict2.mergeWith = mergeWith;
   let to;
   ((to2) => {
     to2.Record = (m) => Object.fromEntries(m);
   })(to = Dict2.to || (Dict2.to = {}));
+  Dict2.mapEntries = (f) => (data) => {
+    const res = new globalThis.Map();
+    for (const [k, v] of data) {
+      const [nk, nv] = f(k, v);
+      res.set(nk, nv);
+    }
+    return res;
+  };
+  Dict2.mapKeys = (f) => (data) => {
+    const res = new globalThis.Map();
+    for (const [k, v] of data) {
+      res.set(f(k), v);
+    }
+    return res;
+  };
   Dict2.NonEmpty = DictNonEmpty;
 })(Dict || (Dict = {}));
 
+// src/Data/Json.ts
+var isSyntaxError = (err2) => typeof err2 === "object" && err2 !== null && "name" in err2 && err2.name === "SyntaxError";
+var isTypeError = (err2) => typeof err2 === "object" && err2 !== null && "name" in err2 && err2.name === "TypeError";
+var Json;
+((Json2) => {
+  Json2.parse = (text) => Result.tryCatch(() => JSON.parse(text), {
+    onError: (err2) => isSyntaxError(err2) ? err2 : new SyntaxError(String(err2))
+  });
+  Json2.stringify = (value, replacer, space) => Result.tryCatch(() => JSON.stringify(value, replacer, space), {
+    onError: (err2) => isTypeError(err2) ? err2 : new TypeError(String(err2))
+  });
+})(Json || (Json = {}));
+
 // src/Data/Num.ts
 var Num;
 ((Num2) => {
+  let is;
+  ((is2) => {
+    is2.zero = (n) => n === 0;
+    is2.integer = (n) => Number.isInteger(n);
+    is2.float = (n) => Number.isFinite(n) && !Number.isInteger(n);
+    is2.finite = (n) => Number.isFinite(n);
+    is2.nan = (n) => Number.isNaN(n);
+    is2.even = (n) => Number.isInteger(n) && n % 2 === 0;
+    is2.odd = (n) => Number.isInteger(n) && n % 2 !== 0;
+    is2.positive = (n) => n > 0;
+    is2.negative = (n) => n < 0;
+  })(is = Num2.is || (Num2.is = {}));
   Num2.range = (from, to, step = 1) => {
     if (step <= 0 || from > to) {
       return [];
@@ -3396,6 +3847,7 @@ var Num;
     }
     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
@@ -3583,6 +4035,36 @@ var Rec;
     ...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 = {};
@@ -3600,6 +4082,25 @@ var Rec;
     }
     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;
@@ -3682,6 +4183,17 @@ var Str;
       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 = {}));
 
@@ -3812,12 +4324,14 @@ var Uniq;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Arr,
+  BigNum,
   Brand,
   Combinable,
   Deferred,
   Dict,
   Duration,
   Equality,
+  Json,
   Lazy,
   Lens,
   Logged,
@@ -3833,6 +4347,7 @@ var Uniq;
   RemoteData,
   Resource,
   Result,
+  RetryPolicy,
   State,
   Str,
   Task,
@@ -3868,7 +4383,9 @@ var Uniq;
   or,
   pipe,
   tap,
+  tuple,
   uncurry,
   uncurry3,
-  uncurry4
+  uncurry4,
+  untuple
 });