@nlozgachev/pipelined 0.26.0 → 0.28.0

package/dist/index.js

@@ -375,8 +375,9 @@ var Result;
     if ((0, Result2.isErr)(data)) f(data.error);
     return data;
   };
+  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (blockedErr, fallback) => (data) => (0, Result2.isErr)(data) && data.error !== blockedErr ? fallback() : data;
+  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
 })(Result || (Result = {}));
@@ -392,7 +393,6 @@ var Maybe;
   Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
   Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
   Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
-  Maybe2.fromUndefined = (value) => value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
   Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
   Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
   Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
@@ -1445,10 +1445,15 @@ var RemoteData;
     if ((0, RemoteData2.isSuccess)(data)) f(data.value);
     return data;
   };
+  RemoteData2.tapError = (f) => (data) => {
+    if ((0, RemoteData2.isFailure)(data)) f(data.error);
+    return data;
+  };
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
   RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
   RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
   RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
+  RemoteData2.fromMaybe = (onNone) => (data) => Maybe.isSome(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(onNone());
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Task.ts
@@ -1457,6 +1462,7 @@ var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
   Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.fromSync = (f) => () => Deferred.fromPromise(Promise.resolve(f()));
   Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
   Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
   Task2.ap = (arg) => (data) => (0, Task2.from)(
@@ -1495,13 +1501,14 @@ var Task;
     return run(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
-    const { when: predicate, delay: ms } = options;
+    const { when: predicate, delay: ms, maxAttempts } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task, signal).then((a) => {
+    const run = (attempt) => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
-      return wait().then(run);
+      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+      return wait().then(() => run(attempt + 1));
     });
-    return run();
+    return run(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
@@ -1532,8 +1539,12 @@ var Task;
     ]);
   });
   Task2.abortable = (factory) => {
-    const controller = new AbortController();
+    let currentController = null;
+    const abort = () => currentController?.abort();
     const task = (outerSignal) => {
+      currentController?.abort();
+      currentController = new AbortController();
+      const controller = currentController;
       if (outerSignal) {
         if (outerSignal.aborted) {
           controller.abort(outerSignal.reason);
@@ -1543,7 +1554,7 @@ var Task;
       }
       return Deferred.fromPromise(factory(controller.signal));
     };
-    return { task, abort: () => controller.abort() };
+    return { task, abort };
   };
 })(Task || (Task = {}));
 
@@ -1678,6 +1689,7 @@ var Validation;
   });
   Validation2.isValid = (data) => data.kind === "Valid";
   Validation2.isInvalid = (data) => data.kind === "Invalid";
+  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.valid)(a) : (0, Validation2.invalid)(onFalse(a));
   Validation2.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : data;
   Validation2.ap = (arg) => (data) => {
     if ((0, Validation2.isValid)(data) && (0, Validation2.isValid)(arg)) return (0, Validation2.valid)(data.value(arg.value));
@@ -1694,8 +1706,13 @@ var Validation;
     if ((0, Validation2.isValid)(data)) f(data.value);
     return data;
   };
+  Validation2.tapError = (f) => (data) => {
+    if ((0, Validation2.isInvalid)(data)) f(data.errors);
+    return data;
+  };
   Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (blockedErrors, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some((err2) => blockedErrors.includes(err2)) ? fallback() : data;
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  Validation2.toResult = (data) => (0, Validation2.isValid)(data) ? Result.ok(data.value) : Result.err(data.errors);
   Validation2.product = (first, second) => {
     if ((0, Validation2.isValid)(first) && (0, Validation2.isValid)(second)) return (0, Validation2.valid)([first.value, second.value]);
     const errors = [
@@ -1869,6 +1886,12 @@ var Arr;
     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 = [];
@@ -2195,7 +2218,13 @@ var Num;
   Num2.add = (b) => (a) => a + b;
   Num2.subtract = (b) => (a) => a - b;
   Num2.multiply = (b) => (a) => a * b;
-  Num2.divide = (b) => (a) => a / b;
+  Num2.divide = (b) => (a) => b === 0 ? Maybe.none() : Maybe.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.none() : Maybe.some(n % divisor);
 })(Num || (Num = {}));
 
 // src/Utils/Rec.ts
@@ -2321,6 +2350,12 @@ var Str;
   Str2.toLowerCase = (s) => s.toLowerCase();
   Str2.lines = (s) => s.split(/\r?\n|\r/);
   Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
+  Str2.isEmpty = (s) => s.length === 0;
+  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`.

package/dist/index.mjs

@@ -44,7 +44,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-NTISCH7Z.mjs";
+} from "./chunk-QJS6D6MW.mjs";
 import {
   Arr,
   Dict,
@@ -52,13 +52,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-6H373E63.mjs";
+} from "./chunk-CA3VE4YD.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-Z3DYYR43.mjs";
+} from "./chunk-7JF44HJH.mjs";
 import {
   Brand
 } from "./chunk-BYWKZLHM.mjs";

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-BoqaFsUR.mjs';
+import { M as Maybe, R as Result, T as Task } from './Task-BZT0wedE.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /**
@@ -93,6 +93,18 @@ declare namespace Arr {
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
+    /**
+     * Transforms each element using both its value and its zero-based index.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   ["a", "b", "c"],
+     *   Arr.mapWithIndex((i, s) => ({ position: i + 1, value: s }))
+     * ); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]
+     * ```
+     */
+    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Filters elements that satisfy the predicate.
      *
@@ -846,15 +858,78 @@ declare namespace Num {
      */
     const multiply: (b: number) => (a: number) => number;
     /**
-     * Divides a number by `b`. Data-last: `divide(b)(a)` = `a / b`.
+     * Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
+     *
+     * @example
+     * ```ts
+     * pipe(20, Num.divide(4));                           // Some(5)
+     * pipe(5, Num.divide(0));                            // None
+     * pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]
+     * ```
+     */
+    const divide: (b: number) => (a: number) => Maybe<number>;
+    /**
+     * Returns the absolute value of a number.
+     *
+     * @example
+     * ```ts
+     * pipe(-5, Num.abs); // 5
+     * pipe(5, Num.abs);  // 5
+     * ```
+     */
+    const abs: (n: number) => number;
+    /**
+     * Negates a number (arithmetic negation).
+     *
+     * @example
+     * ```ts
+     * pipe(5, Num.negate);  // -5
+     * pipe(-5, Num.negate); // 5
+     * ```
+     */
+    const negate: (n: number) => number;
+    /**
+     * Rounds a number to the nearest integer.
+     *
+     * @example
+     * ```ts
+     * pipe(3.5, Num.round); // 4
+     * pipe(3.4, Num.round); // 3
+     * ```
+     */
+    const round: (n: number) => number;
+    /**
+     * Rounds a number down to the nearest integer.
+     *
+     * @example
+     * ```ts
+     * pipe(3.9, Num.floor); // 3
+     * pipe(-3.2, Num.floor); // -4
+     * ```
+     */
+    const floor: (n: number) => number;
+    /**
+     * Rounds a number up to the nearest integer.
      *
      * @example
      * ```ts
-     * pipe(20, Num.divide(4));                      // 5
-     * pipe([10, 20, 30], Arr.map(Num.divide(10)));  // [1, 2, 3]
+     * pipe(3.1, Num.ceil); // 4
+     * pipe(-3.9, Num.ceil); // -3
      * ```
      */
-    const divide: (b: number) => (a: number) => number;
+    const ceil: (n: number) => number;
+    /**
+     * Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
+     * Data-last: `remainder(divisor)(a)` = `a % divisor`.
+     *
+     * @example
+     * ```ts
+     * pipe(10, Num.remainder(3));                           // Some(1)
+     * pipe(5, Num.remainder(0));                            // None
+     * pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]
+     * ```
+     */
+    const remainder: (divisor: number) => (n: number) => Maybe<number>;
 }
 
 /**
@@ -1133,6 +1208,66 @@ declare namespace Str {
      * ```
      */
     const words: (s: string) => readonly string[];
+    /**
+     * Returns `true` when the string is empty.
+     *
+     * @example
+     * ```ts
+     * pipe("", Str.isEmpty);   // true
+     * pipe("hi", Str.isEmpty); // false
+     * ```
+     */
+    const isEmpty: (s: string) => boolean;
+    /**
+     * Returns `true` when the string is empty or contains only whitespace.
+     *
+     * @example
+     * ```ts
+     * pipe("   ", Str.isBlank); // true
+     * pipe("hi", Str.isBlank);  // false
+     * ```
+     */
+    const isBlank: (s: string) => boolean;
+    /**
+     * Returns the length of the string.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.length); // 5
+     * pipe("", Str.length);      // 0
+     * ```
+     */
+    const length: (s: string) => number;
+    /**
+     * Extracts a substring between two indices. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.slice(1, 3)); // "el"
+     * pipe("hello", Str.slice(2));    // "llo"
+     * ```
+     */
+    const slice: (start: number, end?: number) => (s: string) => string;
+    /**
+     * Pads the start of a string to a specified length. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("5", Str.padStart(3, "0")); // "005"
+     * pipe("hi", Str.padStart(5));     // "   hi"
+     * ```
+     */
+    const padStart: (maxLength: number, fillString?: string) => (s: string) => string;
+    /**
+     * Pads the end of a string to a specified length. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("hi", Str.padEnd(5, "."));  // "hi..."
+     * pipe("hi", Str.padEnd(5));       // "hi   "
+     * ```
+     */
+    const padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
     /**
      * Safe number parsers that return `Maybe` instead of `NaN`.
      */

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-7brqoQrb.js';
+import { M as Maybe, R as Result, T as Task } from './Task-BW66NsGR.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /**
@@ -93,6 +93,18 @@ declare namespace Arr {
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
+    /**
+     * Transforms each element using both its value and its zero-based index.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   ["a", "b", "c"],
+     *   Arr.mapWithIndex((i, s) => ({ position: i + 1, value: s }))
+     * ); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]
+     * ```
+     */
+    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Filters elements that satisfy the predicate.
      *
@@ -846,15 +858,78 @@ declare namespace Num {
      */
     const multiply: (b: number) => (a: number) => number;
     /**
-     * Divides a number by `b`. Data-last: `divide(b)(a)` = `a / b`.
+     * Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
+     *
+     * @example
+     * ```ts
+     * pipe(20, Num.divide(4));                           // Some(5)
+     * pipe(5, Num.divide(0));                            // None
+     * pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]
+     * ```
+     */
+    const divide: (b: number) => (a: number) => Maybe<number>;
+    /**
+     * Returns the absolute value of a number.
+     *
+     * @example
+     * ```ts
+     * pipe(-5, Num.abs); // 5
+     * pipe(5, Num.abs);  // 5
+     * ```
+     */
+    const abs: (n: number) => number;
+    /**
+     * Negates a number (arithmetic negation).
+     *
+     * @example
+     * ```ts
+     * pipe(5, Num.negate);  // -5
+     * pipe(-5, Num.negate); // 5
+     * ```
+     */
+    const negate: (n: number) => number;
+    /**
+     * Rounds a number to the nearest integer.
+     *
+     * @example
+     * ```ts
+     * pipe(3.5, Num.round); // 4
+     * pipe(3.4, Num.round); // 3
+     * ```
+     */
+    const round: (n: number) => number;
+    /**
+     * Rounds a number down to the nearest integer.
+     *
+     * @example
+     * ```ts
+     * pipe(3.9, Num.floor); // 3
+     * pipe(-3.2, Num.floor); // -4
+     * ```
+     */
+    const floor: (n: number) => number;
+    /**
+     * Rounds a number up to the nearest integer.
      *
      * @example
      * ```ts
-     * pipe(20, Num.divide(4));                      // 5
-     * pipe([10, 20, 30], Arr.map(Num.divide(10)));  // [1, 2, 3]
+     * pipe(3.1, Num.ceil); // 4
+     * pipe(-3.9, Num.ceil); // -3
      * ```
      */
-    const divide: (b: number) => (a: number) => number;
+    const ceil: (n: number) => number;
+    /**
+     * Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
+     * Data-last: `remainder(divisor)(a)` = `a % divisor`.
+     *
+     * @example
+     * ```ts
+     * pipe(10, Num.remainder(3));                           // Some(1)
+     * pipe(5, Num.remainder(0));                            // None
+     * pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]
+     * ```
+     */
+    const remainder: (divisor: number) => (n: number) => Maybe<number>;
 }
 
 /**
@@ -1133,6 +1208,66 @@ declare namespace Str {
      * ```
      */
     const words: (s: string) => readonly string[];
+    /**
+     * Returns `true` when the string is empty.
+     *
+     * @example
+     * ```ts
+     * pipe("", Str.isEmpty);   // true
+     * pipe("hi", Str.isEmpty); // false
+     * ```
+     */
+    const isEmpty: (s: string) => boolean;
+    /**
+     * Returns `true` when the string is empty or contains only whitespace.
+     *
+     * @example
+     * ```ts
+     * pipe("   ", Str.isBlank); // true
+     * pipe("hi", Str.isBlank);  // false
+     * ```
+     */
+    const isBlank: (s: string) => boolean;
+    /**
+     * Returns the length of the string.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.length); // 5
+     * pipe("", Str.length);      // 0
+     * ```
+     */
+    const length: (s: string) => number;
+    /**
+     * Extracts a substring between two indices. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.slice(1, 3)); // "el"
+     * pipe("hello", Str.slice(2));    // "llo"
+     * ```
+     */
+    const slice: (start: number, end?: number) => (s: string) => string;
+    /**
+     * Pads the start of a string to a specified length. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("5", Str.padStart(3, "0")); // "005"
+     * pipe("hi", Str.padStart(5));     // "   hi"
+     * ```
+     */
+    const padStart: (maxLength: number, fillString?: string) => (s: string) => string;
+    /**
+     * Pads the end of a string to a specified length. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("hi", Str.padEnd(5, "."));  // "hi..."
+     * pipe("hi", Str.padEnd(5));       // "hi   "
+     * ```
+     */
+    const padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
     /**
      * Safe number parsers that return `Maybe` instead of `NaN`.
      */

package/dist/utils.js

@@ -67,8 +67,9 @@ var Result;
     if ((0, Result2.isErr)(data)) f(data.error);
     return data;
   };
+  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (blockedErr, fallback) => (data) => (0, Result2.isErr)(data) && data.error !== blockedErr ? fallback() : data;
+  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
 })(Result || (Result = {}));
@@ -84,7 +85,6 @@ var Maybe;
   Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
   Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
   Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
-  Maybe2.fromUndefined = (value) => value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
   Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
   Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
   Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
@@ -108,6 +108,7 @@ var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
   Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.fromSync = (f) => () => Deferred.fromPromise(Promise.resolve(f()));
   Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
   Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
   Task2.ap = (arg) => (data) => (0, Task2.from)(
@@ -146,13 +147,14 @@ var Task;
     return run(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
-    const { when: predicate, delay: ms } = options;
+    const { when: predicate, delay: ms, maxAttempts } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task, signal).then((a) => {
+    const run = (attempt) => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
-      return wait().then(run);
+      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+      return wait().then(() => run(attempt + 1));
     });
-    return run();
+    return run(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
@@ -183,8 +185,12 @@ var Task;
     ]);
   });
   Task2.abortable = (factory) => {
-    const controller = new AbortController();
+    let currentController = null;
+    const abort = () => currentController?.abort();
     const task = (outerSignal) => {
+      currentController?.abort();
+      currentController = new AbortController();
+      const controller = currentController;
       if (outerSignal) {
         if (outerSignal.aborted) {
           controller.abort(outerSignal.reason);
@@ -194,7 +200,7 @@ var Task;
       }
       return Deferred.fromPromise(factory(controller.signal));
     };
-    return { task, abort: () => controller.abort() };
+    return { task, abort };
   };
 })(Task || (Task = {}));
 
@@ -228,6 +234,12 @@ var Arr;
     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 = [];
@@ -554,7 +566,13 @@ var Num;
   Num2.add = (b) => (a) => a + b;
   Num2.subtract = (b) => (a) => a - b;
   Num2.multiply = (b) => (a) => a * b;
-  Num2.divide = (b) => (a) => a / b;
+  Num2.divide = (b) => (a) => b === 0 ? Maybe.none() : Maybe.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.none() : Maybe.some(n % divisor);
 })(Num || (Num = {}));
 
 // src/Utils/Rec.ts
@@ -680,6 +698,12 @@ var Str;
   Str2.toLowerCase = (s) => s.toLowerCase();
   Str2.lines = (s) => s.split(/\r?\n|\r/);
   Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
+  Str2.isEmpty = (s) => s.length === 0;
+  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`.

package/dist/utils.mjs

@@ -5,8 +5,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-6H373E63.mjs";
-import "./chunk-Z3DYYR43.mjs";
+} from "./chunk-CA3VE4YD.mjs";
+import "./chunk-7JF44HJH.mjs";
 import "./chunk-DBIC62UV.mjs";
 export {
   Arr,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.26.0",
+	"version": "0.28.0",
 	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",