@naturalcycles/js-lib 14.72.0 → 14.75.1

package/dist/math/math.util.d.ts

@@ -24,6 +24,10 @@ export declare function _averageWeighted(values: number[], weights: number[]): n
  * // 3
  */
 export declare function _percentile(values: number[], pc: number): number;
+/**
+ * A tiny bit more efficient function than calling _percentile individually.
+ */
+export declare function _percentiles(values: number[], pcs: number[]): Record<number, number>;
 /**
  * @example
  *

package/dist/math/math.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._median = exports._percentile = exports._averageWeighted = exports._average = void 0;
+exports._median = exports._percentiles = exports._percentile = exports._averageWeighted = exports._average = void 0;
 const number_util_1 = require("../number/number.util");
 /**
  * @returns Average of the array of numbers
@@ -45,6 +45,23 @@ function _percentile(values, pc) {
     return _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
 }
 exports._percentile = _percentile;
+/**
+ * A tiny bit more efficient function than calling _percentile individually.
+ */
+function _percentiles(values, pcs) {
+    const r = {};
+    const sorted = (0, number_util_1._sortNumbers)(values);
+    pcs.forEach(pc => {
+        // Floating pos in the range of [0; length - 1]
+        const pos = ((values.length - 1) * pc) / 100;
+        const dec = pos % 1;
+        const floorPos = Math.floor(pos);
+        const ceilPos = Math.ceil(pos);
+        r[pc] = _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
+    });
+    return r;
+}
+exports._percentiles = _percentiles;
 /**
  * @example
  *

package/dist/math/stack.util.d.ts

@@ -1,9 +1,11 @@
 /**
- * Implements a "round-robin" Stack with a limited size.
+ * Implements a "round-robin" Stack ("first-in last-out" aka FILO) with a limited size.
  * Like an array of a fixed size. When it runs out of space - it starts writing on top of itself
  * from index 0.
+ *
+ *
  */
-export declare class SizeLimitedStack<T> {
+export declare class Stack<T> {
     readonly size: number;
     constructor(size: number);
     /**
@@ -12,10 +14,37 @@ export declare class SizeLimitedStack<T> {
      */
     private nextIndex;
     readonly items: T[];
-    push(item: T): void;
+    push(item: T): this;
+    /**
+     * Fill (overwrite) the whole Stack (all its items) with the passed `item`.
+     */
+    fill(item: T): this;
     /**
      * Returns last items in the right order.
      * Unlike raw `items` property that returns "items buffer" as-is (not ordered properly).
      */
     get itemsOrdered(): T[];
 }
+/**
+ * Fixed-size FILO stack of Numbers.
+ * Has convenience stat methods, e.g percentile, avg, etc.
+ */
+export declare class NumberStack extends Stack<number> {
+    avg(): number;
+    /**
+     * Returns null if Stack is empty.
+     */
+    avgOrNull(): number | null;
+    median(): number;
+    medianOrNull(): number | null;
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     */
+    percentile(pc: number): number;
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     * Returns null if Stack is empty.
+     */
+    percentileOrNull(pc: number): number | null;
+    percentiles(pcs: number[]): Record<number, number>;
+}

package/dist/math/stack.util.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SizeLimitedStack = void 0;
+exports.NumberStack = exports.Stack = void 0;
+const index_1 = require("../index");
 /**
- * Implements a "round-robin" Stack with a limited size.
+ * Implements a "round-robin" Stack ("first-in last-out" aka FILO) with a limited size.
  * Like an array of a fixed size. When it runs out of space - it starts writing on top of itself
  * from index 0.
+ *
+ *
  */
-class SizeLimitedStack {
+class Stack {
     constructor(size) {
         this.size = size;
         /**
@@ -19,6 +22,14 @@ class SizeLimitedStack {
     push(item) {
         this.items[this.nextIndex] = item;
         this.nextIndex = this.nextIndex === this.size - 1 ? 0 : this.nextIndex + 1;
+        return this;
+    }
+    /**
+     * Fill (overwrite) the whole Stack (all its items) with the passed `item`.
+     */
+    fill(item) {
+        (0, index_1._range)(this.size).forEach(i => (this.items[i] = item));
+        return this;
     }
     /**
      * Returns last items in the right order.
@@ -33,4 +44,44 @@ class SizeLimitedStack {
         return [...this.items.slice(this.nextIndex), ...this.items.slice(0, this.nextIndex)];
     }
 }
-exports.SizeLimitedStack = SizeLimitedStack;
+exports.Stack = Stack;
+/**
+ * Fixed-size FILO stack of Numbers.
+ * Has convenience stat methods, e.g percentile, avg, etc.
+ */
+class NumberStack extends Stack {
+    avg() {
+        // _assert(this.items.length, 'NumberStack.avg cannot be called on empty stack')
+        return (0, index_1._average)(this.items);
+    }
+    /**
+     * Returns null if Stack is empty.
+     */
+    avgOrNull() {
+        return this.items.length === 0 ? null : (0, index_1._average)(this.items);
+    }
+    median() {
+        return (0, index_1._percentile)(this.items, 50);
+    }
+    medianOrNull() {
+        return this.items.length === 0 ? null : (0, index_1._percentile)(this.items, 50);
+    }
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     */
+    percentile(pc) {
+        // _assert(this.items.length, 'NumberStack.percentile cannot be called on empty stack')
+        return (0, index_1._percentile)(this.items, pc);
+    }
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     * Returns null if Stack is empty.
+     */
+    percentileOrNull(pc) {
+        return this.items.length === 0 ? null : (0, index_1._percentile)(this.items, pc);
+    }
+    percentiles(pcs) {
+        return (0, index_1._percentiles)(this.items, pcs);
+    }
+}
+exports.NumberStack = NumberStack;

package/dist/number/number.util.d.ts

@@ -44,7 +44,7 @@ export declare function _toFixed(n: number, fractionDigits: number): number;
  * _toPrecision(1634.56, 1)
  * // 2000
  *
- * _toPrecision(1234.56, 2)
+ * _toPrecision(1634.56, 2)
  * // 1600
  */
 export declare function _toPrecision(n: number, precision: number): number;

package/dist/number/number.util.js

@@ -67,7 +67,7 @@ exports._toFixed = _toFixed;
  * _toPrecision(1634.56, 1)
  * // 2000
  *
- * _toPrecision(1234.56, 2)
+ * _toPrecision(1634.56, 2)
  * // 1600
  */
 function _toPrecision(n, precision) {

package/dist/seq/seq.d.ts

@@ -1,4 +1,4 @@
-import { AbortableMapper, AbortablePredicate, END } from '../types';
+import { AbortableAsyncMapper, AbortableAsyncPredicate, AbortableMapper, AbortablePredicate, END } from '../types';
 /**
  * Inspired by Kotlin Sequences.
  * Similar to arrays, but with lazy evaluation, abortable.
@@ -7,14 +7,14 @@ import { AbortableMapper, AbortablePredicate, END } from '../types';
  *
  * @experimental
  */
-export declare class Seq<T> implements Iterable<T> {
+export declare class Sequence<T> implements Iterable<T> {
     private nextFn;
     private constructor();
     [Symbol.iterator](): Iterator<T>;
-    static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T>;
-    static range(minIncl: number, maxExcl: number, step?: number): Seq<number>;
-    static from<T>(a: Iterable<T>): Seq<T>;
-    static empty<T = any>(): Seq<T>;
+    static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T>;
+    static range(minIncl: number, maxExcl: number, step?: number): Sequence<number>;
+    static from<T>(a: Iterable<T>): Sequence<T>;
+    static empty<T = any>(): Sequence<T>;
     private currentValue;
     private sentInitialValue;
     private i;
@@ -27,4 +27,26 @@ export declare class Seq<T> implements Iterable<T> {
 /**
  * Convenience function to create a Sequence.
  */
-export declare function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T>;
+export declare function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T>;
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export declare class AsyncSequence<T> implements AsyncIterable<T> {
+    private nextFn;
+    private constructor();
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    static create<T>(initialValue: T | typeof END, nextFn: AbortableAsyncMapper<T, T>): AsyncSequence<T>;
+    static from<T>(a: AsyncIterable<T>): Promise<AsyncSequence<T>>;
+    static empty<T = any>(): AsyncSequence<T>;
+    private currentValue;
+    private sentInitialValue;
+    private i;
+    next(): Promise<T | typeof END>;
+    find(predicate: AbortableAsyncPredicate<T>): Promise<T | undefined>;
+    some(predicate: AbortableAsyncPredicate<T>): Promise<boolean>;
+    every(predicate: AbortableAsyncPredicate<T>): Promise<boolean>;
+    toArray(): Promise<T[]>;
+}

package/dist/seq/seq.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._seq = exports.Seq = void 0;
+exports.AsyncSequence = exports._seq = exports.Sequence = void 0;
 const types_1 = require("../types");
 /**
  * Inspired by Kotlin Sequences.
@@ -10,7 +10,7 @@ const types_1 = require("../types");
  *
  * @experimental
  */
-class Seq {
+class Sequence {
     constructor(initialValue, nextFn) {
         this.nextFn = nextFn;
         this.sentInitialValue = false;
@@ -26,18 +26,18 @@ class Seq {
         };
     }
     static create(initialValue, nextFn) {
-        return new Seq(initialValue, nextFn);
+        return new Sequence(initialValue, nextFn);
     }
     static range(minIncl, maxExcl, step = 1) {
         const max = maxExcl - step;
-        return new Seq(minIncl, n => (n < max ? n + step : types_1.END));
+        return new Sequence(minIncl, n => (n < max ? n + step : types_1.END));
     }
     static from(a) {
         const it = a[Symbol.iterator]();
         const v = it.next();
         if (v.done)
-            return new Seq(types_1.END, () => { });
-        return new Seq(v.value, () => {
+            return new Sequence(types_1.END, () => { });
+        return new Sequence(v.value, () => {
             const v = it.next();
             if (v.done)
                 return types_1.END;
@@ -45,7 +45,7 @@ class Seq {
         });
     }
     static empty() {
-        return new Seq(types_1.END, () => { });
+        return new Sequence(types_1.END, () => { });
     }
     next() {
         if (this.currentValue === types_1.END)
@@ -131,11 +131,118 @@ class Seq {
         }
     }
 }
-exports.Seq = Seq;
+exports.Sequence = Sequence;
 /**
  * Convenience function to create a Sequence.
  */
 function _seq(initialValue, nextFn) {
-    return Seq.create(initialValue, nextFn);
+    return Sequence.create(initialValue, nextFn);
 }
 exports._seq = _seq;
+/* eslint-disable no-await-in-loop */
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+class AsyncSequence {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                return value === types_1.END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new AsyncSequence(initialValue, nextFn);
+    }
+    static async from(a) {
+        const it = a[Symbol.asyncIterator]();
+        const v = await it.next();
+        if (v.done)
+            return new AsyncSequence(types_1.END, () => { });
+        return new AsyncSequence(v.value, async () => {
+            const v = await it.next();
+            if (v.done)
+                return types_1.END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new AsyncSequence(types_1.END, () => { });
+    }
+    async next() {
+        if (this.currentValue === types_1.END)
+            return types_1.END;
+        this.i++;
+        let v;
+        if (!this.sentInitialValue) {
+            this.sentInitialValue = true;
+            v = this.currentValue;
+        }
+        else {
+            v = await this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === types_1.SKIP)
+            return await this.next();
+        return (this.currentValue = v);
+    }
+    // Final functions - return final value, not a chained sequence
+    async find(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return; // not found, end of sequence
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async some(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return false;
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async every(predicate) {
+        do {
+            const v = await this.next();
+            if (v === types_1.END)
+                return true;
+            const r = await predicate(v, this.i);
+            if (r === types_1.END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = await this.next();
+            if (v === types_1.END)
+                return a;
+            a.push(v);
+        }
+    }
+}
+exports.AsyncSequence = AsyncSequence;

package/dist/string/stringifyAny.js

@@ -44,17 +44,19 @@ function _stringifyAny(obj, opt = {}) {
         //
         // Error or ErrorObject
         //
+        // Omit "default" error name as non-informative
+        // UPD: no, it's still important to understand that we're dealing with Error and not just some string
+        // if (obj?.name === 'Error') {
+        //   s = obj.message
+        // }
+        s = [obj.name, obj.message].join(': ');
         if (opt.includeErrorStack && obj.stack) {
-            // Stack includes message
-            s = obj.stack;
-        }
-        else {
-            // Omit "default" error name as non-informative
-            // UPD: no, it's still important to understand that we're dealing with Error and not just some string
-            // if (obj?.name === 'Error') {
-            //   s = obj.message
-            // }
-            s = [obj.name, obj.message].join(': ');
+            // Here we're using the previously-generated "title line" (e.g "Error: some_message"),
+            // concatenating it with the Stack (but without the title line of the Stack)
+            // This is to fix the rare error (happened with Got) where `err.message` was changed,
+            // but err.stack had "old" err.message
+            // This should "fix" that
+            s = [s, ...obj.stack.split('\n').slice(1)].join('\n');
         }
         if ((0, error_util_1._isErrorObject)(obj)) {
             if ((0, error_util_1._isHttpErrorObject)(obj)) {

package/dist-esm/math/math.util.js

@@ -39,6 +39,22 @@ export function _percentile(values, pc) {
     const ceilPos = Math.ceil(pos);
     return _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
 }
+/**
+ * A tiny bit more efficient function than calling _percentile individually.
+ */
+export function _percentiles(values, pcs) {
+    const r = {};
+    const sorted = _sortNumbers(values);
+    pcs.forEach(pc => {
+        // Floating pos in the range of [0; length - 1]
+        const pos = ((values.length - 1) * pc) / 100;
+        const dec = pos % 1;
+        const floorPos = Math.floor(pos);
+        const ceilPos = Math.ceil(pos);
+        r[pc] = _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
+    });
+    return r;
+}
 /**
  * @example
  *

package/dist-esm/math/stack.util.js

@@ -1,9 +1,12 @@
+import { _average, _percentile, _percentiles, _range } from '../index';
 /**
- * Implements a "round-robin" Stack with a limited size.
+ * Implements a "round-robin" Stack ("first-in last-out" aka FILO) with a limited size.
  * Like an array of a fixed size. When it runs out of space - it starts writing on top of itself
  * from index 0.
+ *
+ *
  */
-export class SizeLimitedStack {
+export class Stack {
     constructor(size) {
         this.size = size;
         /**
@@ -16,6 +19,14 @@ export class SizeLimitedStack {
     push(item) {
         this.items[this.nextIndex] = item;
         this.nextIndex = this.nextIndex === this.size - 1 ? 0 : this.nextIndex + 1;
+        return this;
+    }
+    /**
+     * Fill (overwrite) the whole Stack (all its items) with the passed `item`.
+     */
+    fill(item) {
+        _range(this.size).forEach(i => (this.items[i] = item));
+        return this;
     }
     /**
      * Returns last items in the right order.
@@ -30,3 +41,42 @@ export class SizeLimitedStack {
         return [...this.items.slice(this.nextIndex), ...this.items.slice(0, this.nextIndex)];
     }
 }
+/**
+ * Fixed-size FILO stack of Numbers.
+ * Has convenience stat methods, e.g percentile, avg, etc.
+ */
+export class NumberStack extends Stack {
+    avg() {
+        // _assert(this.items.length, 'NumberStack.avg cannot be called on empty stack')
+        return _average(this.items);
+    }
+    /**
+     * Returns null if Stack is empty.
+     */
+    avgOrNull() {
+        return this.items.length === 0 ? null : _average(this.items);
+    }
+    median() {
+        return _percentile(this.items, 50);
+    }
+    medianOrNull() {
+        return this.items.length === 0 ? null : _percentile(this.items, 50);
+    }
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     */
+    percentile(pc) {
+        // _assert(this.items.length, 'NumberStack.percentile cannot be called on empty stack')
+        return _percentile(this.items, pc);
+    }
+    /**
+     * `pc` is a number from 0 to 100 inclusive.
+     * Returns null if Stack is empty.
+     */
+    percentileOrNull(pc) {
+        return this.items.length === 0 ? null : _percentile(this.items, pc);
+    }
+    percentiles(pcs) {
+        return _percentiles(this.items, pcs);
+    }
+}

package/dist-esm/number/number.util.js

@@ -58,7 +58,7 @@ export function _toFixed(n, fractionDigits) {
  * _toPrecision(1634.56, 1)
  * // 2000
  *
- * _toPrecision(1234.56, 2)
+ * _toPrecision(1634.56, 2)
  * // 1600
  */
 export function _toPrecision(n, precision) {

package/dist-esm/seq/seq.js

@@ -1,4 +1,4 @@
-import { END, SKIP } from '../types';
+import { END, SKIP, } from '../types';
 /**
  * Inspired by Kotlin Sequences.
  * Similar to arrays, but with lazy evaluation, abortable.
@@ -7,7 +7,7 @@ import { END, SKIP } from '../types';
  *
  * @experimental
  */
-export class Seq {
+export class Sequence {
     constructor(initialValue, nextFn) {
         this.nextFn = nextFn;
         this.sentInitialValue = false;
@@ -23,18 +23,18 @@ export class Seq {
         };
     }
     static create(initialValue, nextFn) {
-        return new Seq(initialValue, nextFn);
+        return new Sequence(initialValue, nextFn);
     }
     static range(minIncl, maxExcl, step = 1) {
         const max = maxExcl - step;
-        return new Seq(minIncl, n => (n < max ? n + step : END));
+        return new Sequence(minIncl, n => (n < max ? n + step : END));
     }
     static from(a) {
         const it = a[Symbol.iterator]();
         const v = it.next();
         if (v.done)
-            return new Seq(END, () => { });
-        return new Seq(v.value, () => {
+            return new Sequence(END, () => { });
+        return new Sequence(v.value, () => {
             const v = it.next();
             if (v.done)
                 return END;
@@ -42,7 +42,7 @@ export class Seq {
         });
     }
     static empty() {
-        return new Seq(END, () => { });
+        return new Sequence(END, () => { });
     }
     next() {
         if (this.currentValue === END)
@@ -132,5 +132,111 @@ export class Seq {
  * Convenience function to create a Sequence.
  */
 export function _seq(initialValue, nextFn) {
-    return Seq.create(initialValue, nextFn);
+    return Sequence.create(initialValue, nextFn);
+}
+/* eslint-disable no-await-in-loop */
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export class AsyncSequence {
+    constructor(initialValue, nextFn) {
+        this.nextFn = nextFn;
+        this.sentInitialValue = false;
+        this.i = -1;
+        this.currentValue = initialValue;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                return value === END ? { done: true, value: undefined } : { value };
+            },
+        };
+    }
+    static create(initialValue, nextFn) {
+        return new AsyncSequence(initialValue, nextFn);
+    }
+    static async from(a) {
+        const it = a[Symbol.asyncIterator]();
+        const v = await it.next();
+        if (v.done)
+            return new AsyncSequence(END, () => { });
+        return new AsyncSequence(v.value, async () => {
+            const v = await it.next();
+            if (v.done)
+                return END;
+            return v.value;
+        });
+    }
+    static empty() {
+        return new AsyncSequence(END, () => { });
+    }
+    async next() {
+        if (this.currentValue === END)
+            return END;
+        this.i++;
+        let v;
+        if (!this.sentInitialValue) {
+            this.sentInitialValue = true;
+            v = this.currentValue;
+        }
+        else {
+            v = await this.nextFn(this.currentValue, this.i);
+        }
+        // console.log(`_seq`, v)
+        if (v === SKIP)
+            return await this.next();
+        return (this.currentValue = v);
+    }
+    // Final functions - return final value, not a chained sequence
+    async find(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return; // not found, end of sequence
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return;
+            if (r)
+                return v;
+            // otherwise proceed
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async some(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return false;
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return false;
+            if (r)
+                return true;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async every(predicate) {
+        do {
+            const v = await this.next();
+            if (v === END)
+                return true;
+            const r = await predicate(v, this.i);
+            if (r === END)
+                return true;
+            if (!r)
+                return false;
+        } while (true); // eslint-disable-line no-constant-condition
+    }
+    async toArray() {
+        const a = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const v = await this.next();
+            if (v === END)
+                return a;
+            a.push(v);
+        }
+    }
 }

package/dist-esm/string/stringifyAny.js

@@ -41,17 +41,19 @@ export function _stringifyAny(obj, opt = {}) {
         //
         // Error or ErrorObject
         //
+        // Omit "default" error name as non-informative
+        // UPD: no, it's still important to understand that we're dealing with Error and not just some string
+        // if (obj?.name === 'Error') {
+        //   s = obj.message
+        // }
+        s = [obj.name, obj.message].join(': ');
         if (opt.includeErrorStack && obj.stack) {
-            // Stack includes message
-            s = obj.stack;
-        }
-        else {
-            // Omit "default" error name as non-informative
-            // UPD: no, it's still important to understand that we're dealing with Error and not just some string
-            // if (obj?.name === 'Error') {
-            //   s = obj.message
-            // }
-            s = [obj.name, obj.message].join(': ');
+            // Here we're using the previously-generated "title line" (e.g "Error: some_message"),
+            // concatenating it with the Stack (but without the title line of the Stack)
+            // This is to fix the rare error (happened with Got) where `err.message` was changed,
+            // but err.stack had "old" err.message
+            // This should "fix" that
+            s = [s, ...obj.stack.split('\n').slice(1)].join('\n');
         }
         if (_isErrorObject(obj)) {
             if (_isHttpErrorObject(obj)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.72.0",
+  "version": "14.75.1",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/math/math.util.ts

@@ -47,6 +47,27 @@ export function _percentile(values: number[], pc: number): number {
   return _averageWeighted([sorted[floorPos]!, sorted[ceilPos]!], [1 - dec, dec])
 }
 
+/**
+ * A tiny bit more efficient function than calling _percentile individually.
+ */
+export function _percentiles(values: number[], pcs: number[]): Record<number, number> {
+  const r = {} as Record<number, number>
+
+  const sorted = _sortNumbers(values)
+
+  pcs.forEach(pc => {
+    // Floating pos in the range of [0; length - 1]
+    const pos = ((values.length - 1) * pc) / 100
+    const dec = pos % 1
+    const floorPos = Math.floor(pos)
+    const ceilPos = Math.ceil(pos)
+
+    r[pc] = _averageWeighted([sorted[floorPos]!, sorted[ceilPos]!], [1 - dec, dec])
+  })
+
+  return r
+}
+
 /**
  * @example
  *

package/src/math/stack.util.ts

@@ -1,9 +1,13 @@
+import { _average, _percentile, _percentiles, _range } from '../index'
+
 /**
- * Implements a "round-robin" Stack with a limited size.
+ * Implements a "round-robin" Stack ("first-in last-out" aka FILO) with a limited size.
  * Like an array of a fixed size. When it runs out of space - it starts writing on top of itself
  * from index 0.
+ *
+ *
  */
-export class SizeLimitedStack<T> {
+export class Stack<T> {
   constructor(public readonly size: number) {}
 
   /**
@@ -14,9 +18,18 @@ export class SizeLimitedStack<T> {
 
   readonly items: T[] = []
 
-  push(item: T): void {
+  push(item: T): this {
     this.items[this.nextIndex] = item
     this.nextIndex = this.nextIndex === this.size - 1 ? 0 : this.nextIndex + 1
+    return this
+  }
+
+  /**
+   * Fill (overwrite) the whole Stack (all its items) with the passed `item`.
+   */
+  fill(item: T): this {
+    _range(this.size).forEach(i => (this.items[i] = item))
+    return this
   }
 
   /**
@@ -33,3 +46,49 @@ export class SizeLimitedStack<T> {
     return [...this.items.slice(this.nextIndex), ...this.items.slice(0, this.nextIndex)]
   }
 }
+
+/**
+ * Fixed-size FILO stack of Numbers.
+ * Has convenience stat methods, e.g percentile, avg, etc.
+ */
+export class NumberStack extends Stack<number> {
+  avg(): number {
+    // _assert(this.items.length, 'NumberStack.avg cannot be called on empty stack')
+    return _average(this.items)
+  }
+
+  /**
+   * Returns null if Stack is empty.
+   */
+  avgOrNull(): number | null {
+    return this.items.length === 0 ? null : _average(this.items)
+  }
+
+  median(): number {
+    return _percentile(this.items, 50)
+  }
+
+  medianOrNull(): number | null {
+    return this.items.length === 0 ? null : _percentile(this.items, 50)
+  }
+
+  /**
+   * `pc` is a number from 0 to 100 inclusive.
+   */
+  percentile(pc: number): number {
+    // _assert(this.items.length, 'NumberStack.percentile cannot be called on empty stack')
+    return _percentile(this.items, pc)
+  }
+
+  /**
+   * `pc` is a number from 0 to 100 inclusive.
+   * Returns null if Stack is empty.
+   */
+  percentileOrNull(pc: number): number | null {
+    return this.items.length === 0 ? null : _percentile(this.items, pc)
+  }
+
+  percentiles(pcs: number[]): Record<number, number> {
+    return _percentiles(this.items, pcs)
+  }
+}

package/src/number/number.util.ts

@@ -65,7 +65,7 @@ export function _toFixed(n: number, fractionDigits: number): number {
  * _toPrecision(1634.56, 1)
  * // 2000
  *
- * _toPrecision(1234.56, 2)
+ * _toPrecision(1634.56, 2)
  * // 1600
  */
 export function _toPrecision(n: number, precision: number): number {

package/src/seq/seq.ts

@@ -1,4 +1,11 @@
-import { AbortableMapper, AbortablePredicate, END, SKIP } from '../types'
+import {
+  AbortableAsyncMapper,
+  AbortableAsyncPredicate,
+  AbortableMapper,
+  AbortablePredicate,
+  END,
+  SKIP,
+} from '../types'
 
 /**
  * Inspired by Kotlin Sequences.
@@ -8,7 +15,7 @@ import { AbortableMapper, AbortablePredicate, END, SKIP } from '../types'
  *
  * @experimental
  */
-export class Seq<T> implements Iterable<T> {
+export class Sequence<T> implements Iterable<T> {
   private constructor(initialValue: T | typeof END, private nextFn: AbortableMapper<T, T>) {
     this.currentValue = initialValue
   }
@@ -22,29 +29,29 @@ export class Seq<T> implements Iterable<T> {
     }
   }
 
-  static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
-    return new Seq(initialValue, nextFn)
+  static create<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T> {
+    return new Sequence(initialValue, nextFn)
   }
 
-  static range(minIncl: number, maxExcl: number, step = 1): Seq<number> {
+  static range(minIncl: number, maxExcl: number, step = 1): Sequence<number> {
     const max = maxExcl - step
-    return new Seq(minIncl, n => (n < max ? n + step : END))
+    return new Sequence(minIncl, n => (n < max ? n + step : END))
   }
 
-  static from<T>(a: Iterable<T>): Seq<T> {
+  static from<T>(a: Iterable<T>): Sequence<T> {
     const it = a[Symbol.iterator]()
     const v = it.next()
-    if (v.done) return new Seq<any>(END, () => {})
+    if (v.done) return new Sequence<any>(END, () => {})
 
-    return new Seq(v.value, () => {
+    return new Sequence(v.value, () => {
       const v = it.next()
       if (v.done) return END
       return v.value
     })
   }
 
-  static empty<T = any>(): Seq<T> {
-    return new Seq(END as any, () => {})
+  static empty<T = any>(): Sequence<T> {
+    return new Sequence(END as any, () => {})
   }
 
   private currentValue: T | typeof END
@@ -138,6 +145,120 @@ export class Seq<T> implements Iterable<T> {
 /**
  * Convenience function to create a Sequence.
  */
-export function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Seq<T> {
-  return Seq.create(initialValue, nextFn)
+export function _seq<T>(initialValue: T | typeof END, nextFn: AbortableMapper<T, T>): Sequence<T> {
+  return Sequence.create(initialValue, nextFn)
+}
+
+/* eslint-disable no-await-in-loop */
+
+/**
+ * Experimental.
+ * Feasibility to be proven.
+ *
+ * @experimental
+ */
+export class AsyncSequence<T> implements AsyncIterable<T> {
+  private constructor(initialValue: T | typeof END, private nextFn: AbortableAsyncMapper<T, T>) {
+    this.currentValue = initialValue
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return {
+      next: async () => {
+        const value = await this.next()
+        return value === END ? { done: true, value: undefined } : { value }
+      },
+    }
+  }
+
+  static create<T>(
+    initialValue: T | typeof END,
+    nextFn: AbortableAsyncMapper<T, T>,
+  ): AsyncSequence<T> {
+    return new AsyncSequence(initialValue, nextFn)
+  }
+
+  static async from<T>(a: AsyncIterable<T>): Promise<AsyncSequence<T>> {
+    const it = a[Symbol.asyncIterator]()
+    const v = await it.next()
+    if (v.done) return new AsyncSequence<any>(END, () => {})
+
+    return new AsyncSequence(v.value, async () => {
+      const v = await it.next()
+      if (v.done) return END
+      return v.value
+    })
+  }
+
+  static empty<T = any>(): AsyncSequence<T> {
+    return new AsyncSequence(END as any, () => {})
+  }
+
+  private currentValue: T | typeof END
+  private sentInitialValue = false
+  private i = -1
+
+  async next(): Promise<T | typeof END> {
+    if (this.currentValue === END) return END
+
+    this.i++
+
+    let v: T | typeof SKIP | typeof END
+
+    if (!this.sentInitialValue) {
+      this.sentInitialValue = true
+      v = this.currentValue
+    } else {
+      v = await this.nextFn(this.currentValue, this.i)
+    }
+
+    // console.log(`_seq`, v)
+
+    if (v === SKIP) return await this.next()
+
+    return (this.currentValue = v)
+  }
+
+  // Final functions - return final value, not a chained sequence
+  async find(predicate: AbortableAsyncPredicate<T>): Promise<T | undefined> {
+    do {
+      const v = await this.next()
+      if (v === END) return // not found, end of sequence
+      const r = await predicate(v, this.i)
+      if (r === END) return
+      if (r) return v
+      // otherwise proceed
+    } while (true) // eslint-disable-line no-constant-condition
+  }
+
+  async some(predicate: AbortableAsyncPredicate<T>): Promise<boolean> {
+    do {
+      const v = await this.next()
+      if (v === END) return false
+      const r = await predicate(v, this.i)
+      if (r === END) return false
+      if (r) return true
+    } while (true) // eslint-disable-line no-constant-condition
+  }
+
+  async every(predicate: AbortableAsyncPredicate<T>): Promise<boolean> {
+    do {
+      const v = await this.next()
+      if (v === END) return true
+      const r = await predicate(v, this.i)
+      if (r === END) return true
+      if (!r) return false
+    } while (true) // eslint-disable-line no-constant-condition
+  }
+
+  async toArray(): Promise<T[]> {
+    const a: T[] = []
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const v = await this.next()
+      if (v === END) return a
+      a.push(v)
+    }
+  }
 }

package/src/string/stringifyAny.ts

@@ -76,16 +76,20 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
     // Error or ErrorObject
     //
 
+    // Omit "default" error name as non-informative
+    // UPD: no, it's still important to understand that we're dealing with Error and not just some string
+    // if (obj?.name === 'Error') {
+    //   s = obj.message
+    // }
+    s = [obj.name, obj.message].join(': ')
+
     if (opt.includeErrorStack && obj.stack) {
-      // Stack includes message
-      s = obj.stack
-    } else {
-      // Omit "default" error name as non-informative
-      // UPD: no, it's still important to understand that we're dealing with Error and not just some string
-      // if (obj?.name === 'Error') {
-      //   s = obj.message
-      // }
-      s = [obj.name, obj.message].join(': ')
+      // Here we're using the previously-generated "title line" (e.g "Error: some_message"),
+      // concatenating it with the Stack (but without the title line of the Stack)
+      // This is to fix the rare error (happened with Got) where `err.message` was changed,
+      // but err.stack had "old" err.message
+      // This should "fix" that
+      s = [s, ...obj.stack.split('\n').slice(1)].join('\n')
     }
 
     if (_isErrorObject(obj)) {