@nlozgachev/pipelined 0.46.0 → 0.48.0

package/dist/{utils.js → data.js}

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Data_exports = {};
 __export(Data_exports, {
   Arr: () => Arr,
+  BigNum: () => BigNum,
   Dict: () => Dict,
+  Json: () => Json,
   Num: () => Num,
   Rec: () => Rec,
   Str: () => Str,
@@ -43,6 +45,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/Maybe.ts
@@ -102,6 +106,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/Types/Brand.ts
@@ -145,11 +150,11 @@ var Result;
     is2.ok = (data) => data.kind === "Ok";
     is2.err = (data) => data.kind === "Err";
   })(is = Result3.is || (Result3.is = {}));
-  Result3.tryCatch = (f, onError) => {
+  Result3.tryCatch = (f, options) => {
     try {
       return make.ok(f());
     } catch (error) {
-      return make.err(onError(error));
+      return make.err(options.onError(error));
     }
   };
   Result3.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
@@ -175,20 +180,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 = 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)(
@@ -207,13 +215,20 @@ var Result;
     }
     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) => {
-  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);
@@ -269,19 +284,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);
@@ -321,6 +345,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
@@ -329,9 +407,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);
@@ -549,7 +633,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 = () => {
@@ -606,6 +691,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;
@@ -625,6 +734,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));
@@ -640,6 +756,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();
@@ -659,7 +781,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 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) => {
@@ -1082,9 +1211,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) => {
@@ -1241,16 +1515,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 = (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 [];
@@ -1314,6 +1658,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
@@ -1501,6 +1846,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 = {};
@@ -1518,6 +1893,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;
@@ -1600,6 +1994,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 = {}));
 
@@ -1730,7 +2135,9 @@ var Uniq;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Arr,
+  BigNum,
   Dict,
+  Json,
   Num,
   Rec,
   Str,

package/dist/data.mjs

@@ -0,0 +1,22 @@
+import {
+  Arr,
+  BigNum,
+  Dict,
+  Json,
+  Num,
+  Rec,
+  Str,
+  Uniq
+} from "./chunk-UGVU2RTM.mjs";
+import "./chunk-LR63GW6J.mjs";
+import "./chunk-DENXUTKL.mjs";
+export {
+  Arr,
+  BigNum,
+  Dict,
+  Json,
+  Num,
+  Rec,
+  Str,
+  Uniq
+};

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.mjs';
+export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple } from './composition.mjs';
 export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.mjs';
-export { D as Deferred } from './InternalTypes-CLE7qlOc.mjs';
-export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-v38R0qH-.mjs';
-export { Arr, Dict, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './utils.mjs';
-export { Brand, Duration } from './types.mjs';
+export { D as Deferred } from './InternalTypes-CDiDBAY4.mjs';
+export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-D-aARYlP.mjs';
+export { Arr, BigNum, Dict, Json, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './data.mjs';
+export { B as Brand, D as Duration } from './Duration-B8joKzro.mjs';
+export { RetryPolicy } from './types.mjs';

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.js';
+export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple } from './composition.js';
 export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.js';
-export { D as Deferred } from './InternalTypes-Mssktd7z.js';
-export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-BMsvixWH.js';
-export { Arr, Dict, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './utils.js';
-export { Brand, Duration } from './types.js';
+export { D as Deferred } from './InternalTypes-LdhLQx3N.js';
+export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-1OgJJdeA.js';
+export { Arr, BigNum, Dict, Json, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './data.js';
+export { B as Brand, D as Duration } from './Duration-B8joKzro.js';
+export { RetryPolicy } from './types.js';