@naturalcycles/js-lib 14.217.0 → 14.219.0

package/dist/array/array.util.d.ts

@@ -115,8 +115,13 @@ export declare function _dropWhile<T>(items: T[], predicate: Predicate<T>): T[];
 export declare function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[];
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
+export declare function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number;
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export declare function _count<T>(items: T[], predicate: AbortablePredicate<T>): number;
 export declare function _countBy<T>(items: T[], mapper: Mapper<T, any>): StringMap<number>;
 /**
  * Returns an intersection between 2 arrays.

package/dist/array/array.util.js

@@ -206,19 +206,29 @@ function _dropRightWhile(items, predicate) {
 exports._dropRightWhile = _dropRightWhile;
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-function _count(items, predicate) {
+function _count(items, predicate, limit) {
+    if (limit === 0)
+        return 0;
     let count = 0;
     for (const [i, item] of items.entries()) {
         const r = predicate(item, i);
         if (r === types_1.END)
             break;
-        if (r)
+        if (r) {
             count++;
+            if (limit && count >= limit)
+                break;
+        }
     }
     return count;
 }
 exports._count = _count;
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
 function _countBy(items, mapper) {
     const map = {};
     items.forEach((item, i) => {

package/dist/promise/pMap.d.ts

@@ -4,7 +4,11 @@ export interface PMapOptions {
     /**
      * Number of concurrently pending promises returned by `mapper`.
      *
-     * @default Infinity
+     * Defaults to 16.
+     *
+     * It previously (and originally) defaulted to Infinity, which was later changed,
+     * because it's somewhat dangerous to run "infinite number of parallel promises".
+     * You can still emulate the old behavior by passing `Infinity`.
      */
     concurrency?: number;
     /**
@@ -23,6 +27,14 @@ export interface PMapOptions {
     logger?: CommonLogger | null;
 }
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.

package/dist/promise/pMap.js

@@ -1,16 +1,16 @@
 "use strict";
-/*
-Taken from https://github.com/sindresorhus/p-map
-
-Improvements:
-- Exported as { pMap }, so IDE auto-completion works
-- Included Typescript typings (no need for @types/p-map)
-- Compatible with pProps (that had typings issues)
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pMap = void 0;
 const __1 = require("..");
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.
@@ -37,70 +37,26 @@ const __1 = require("..");
  * })();
  */
 async function pMap(iterable, mapper, opt = {}) {
-    const { logger = console } = opt;
-    const ret = [];
-    // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
     const itemsLength = items.length;
     if (itemsLength === 0)
         return []; // short circuit
-    const { concurrency = itemsLength, errorMode = __1.ErrorMode.THROW_IMMEDIATELY } = opt;
-    const errors = [];
-    let isSettled = false;
-    let resolvingCount = 0;
-    let currentIndex = 0;
+    const { concurrency = 16, errorMode = __1.ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
     // Special cases that are able to preserve async stack traces
+    // Special case: serial execution
     if (concurrency === 1) {
-        // Special case for concurrency == 1
-        for (const item of items) {
-            try {
-                const r = await mapper(item, currentIndex++);
-                if (r === __1.END)
-                    break;
-                if (r !== __1.SKIP)
-                    ret.push(r);
-            }
-            catch (err) {
-                if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY)
-                    throw err;
-                if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
-                    errors.push(err);
-                }
-                else {
-                    // otherwise, suppress (but still log via logger)
-                    logger?.error(err);
-                }
-            }
-        }
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+        return await pMap1(items, mapper, errorMode, logger);
     }
-    else if (!opt.concurrency || items.length <= opt.concurrency) {
-        // Special case for concurrency == infinity or iterable.length < concurrency
-        if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
-            return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== __1.SKIP && r !== __1.END);
-        }
-        ;
-        (await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
-            if (r.status === 'fulfilled') {
-                if (r.value !== __1.SKIP && r.value !== __1.END)
-                    ret.push(r.value);
-            }
-            else if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
-                errors.push(r.reason);
-            }
-            else {
-                // otherwise, suppress (but still log via logger)
-                logger?.error(r.reason);
-            }
-        });
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+    // Special case: concurrency === Infinity or items.length <= concurrency
+    if (concurrency === Infinity || items.length <= concurrency) {
+        return await pMapAll(items, mapper, errorMode, logger);
     }
+    // General case: execution with throttled concurrency
+    const ret = [];
+    const errors = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
     return await new Promise((resolve, reject) => {
         const next = () => {
             if (isSettled) {
@@ -159,3 +115,64 @@ async function pMap(iterable, mapper, opt = {}) {
     });
 }
 exports.pMap = pMap;
+/**
+ pMap with serial (non-concurrent) execution.
+ */
+async function pMap1(items, mapper, errorMode, logger) {
+    let i = 0;
+    const ret = [];
+    const errors = [];
+    for (const item of items) {
+        try {
+            const r = await mapper(item, i++);
+            if (r === __1.END)
+                break;
+            if (r !== __1.SKIP)
+                ret.push(r);
+        }
+        catch (err) {
+            if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY)
+                throw err;
+            if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                errors.push(err);
+            }
+            else {
+                // otherwise, suppress (but still log via logger)
+                logger?.error(err);
+            }
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}
+/**
+ pMap with fully concurrent execution, like Promise.all
+ */
+async function pMapAll(items, mapper, errorMode, logger) {
+    if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
+        return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== __1.SKIP && r !== __1.END);
+    }
+    const ret = [];
+    const errors = [];
+    for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
+        if (r.status === 'fulfilled') {
+            if (r.value === __1.END)
+                break;
+            if (r.value !== __1.SKIP)
+                ret.push(r.value);
+        }
+        else if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+            errors.push(r.reason);
+        }
+        else {
+            // otherwise, suppress (but still log via logger)
+            logger?.error(r.reason);
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}

package/dist/string/leven.d.ts

@@ -2,5 +2,8 @@
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-export declare function _leven(first: string, second: string): number;
+export declare function _leven(first: string, second: string, limit?: number): number;

package/dist/string/leven.js

@@ -8,9 +8,12 @@ const characterCodeCache = [];
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-function _leven(first, second) {
-    if (first === second) {
+function _leven(first, second, limit) {
+    if (first === second || limit === 0) {
         return 0;
     }
     const swap = first;
@@ -40,6 +43,8 @@ function _leven(first, second) {
     firstLength -= start;
     secondLength -= start;
     if (firstLength === 0) {
+        if (limit && secondLength >= limit)
+            return limit;
         return secondLength;
     }
     let bCharacterCode;
@@ -56,6 +61,8 @@ function _leven(first, second) {
         bCharacterCode = second.charCodeAt(start + index2);
         temporary = index2++;
         result = index2;
+        if (limit && result >= limit)
+            return limit; // exit early on limit
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];

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

@@ -188,18 +188,28 @@ export function _dropRightWhile(items, predicate) {
 }
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export function _count(items, predicate) {
+export function _count(items, predicate, limit) {
+    if (limit === 0)
+        return 0;
     let count = 0;
     for (const [i, item] of items.entries()) {
         const r = predicate(item, i);
         if (r === END)
             break;
-        if (r)
+        if (r) {
             count++;
+            if (limit && count >= limit)
+                break;
+        }
     }
     return count;
 }
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
 export function _countBy(items, mapper) {
     const map = {};
     items.forEach((item, i) => {

package/dist-esm/promise/pMap.js

@@ -1,13 +1,13 @@
-/*
-Taken from https://github.com/sindresorhus/p-map
-
-Improvements:
-- Exported as { pMap }, so IDE auto-completion works
-- Included Typescript typings (no need for @types/p-map)
-- Compatible with pProps (that had typings issues)
- */
 import { END, ErrorMode, SKIP } from '..';
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.
@@ -34,70 +34,26 @@ import { END, ErrorMode, SKIP } from '..';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
-    const { logger = console } = opt;
-    const ret = [];
-    // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
     const itemsLength = items.length;
     if (itemsLength === 0)
         return []; // short circuit
-    const { concurrency = itemsLength, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt;
-    const errors = [];
-    let isSettled = false;
-    let resolvingCount = 0;
-    let currentIndex = 0;
+    const { concurrency = 16, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
     // Special cases that are able to preserve async stack traces
+    // Special case: serial execution
     if (concurrency === 1) {
-        // Special case for concurrency == 1
-        for (const item of items) {
-            try {
-                const r = await mapper(item, currentIndex++);
-                if (r === END)
-                    break;
-                if (r !== SKIP)
-                    ret.push(r);
-            }
-            catch (err) {
-                if (errorMode === ErrorMode.THROW_IMMEDIATELY)
-                    throw err;
-                if (errorMode === ErrorMode.THROW_AGGREGATED) {
-                    errors.push(err);
-                }
-                else {
-                    // otherwise, suppress (but still log via logger)
-                    logger === null || logger === void 0 ? void 0 : logger.error(err);
-                }
-            }
-        }
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+        return await pMap1(items, mapper, errorMode, logger);
     }
-    else if (!opt.concurrency || items.length <= opt.concurrency) {
-        // Special case for concurrency == infinity or iterable.length < concurrency
-        if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
-            return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== SKIP && r !== END);
-        }
-        ;
-        (await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
-            if (r.status === 'fulfilled') {
-                if (r.value !== SKIP && r.value !== END)
-                    ret.push(r.value);
-            }
-            else if (errorMode === ErrorMode.THROW_AGGREGATED) {
-                errors.push(r.reason);
-            }
-            else {
-                // otherwise, suppress (but still log via logger)
-                logger === null || logger === void 0 ? void 0 : logger.error(r.reason);
-            }
-        });
-        if (errors.length) {
-            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
-        }
-        return ret;
+    // Special case: concurrency === Infinity or items.length <= concurrency
+    if (concurrency === Infinity || items.length <= concurrency) {
+        return await pMapAll(items, mapper, errorMode, logger);
     }
+    // General case: execution with throttled concurrency
+    const ret = [];
+    const errors = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
     return await new Promise((resolve, reject) => {
         const next = () => {
             if (isSettled) {
@@ -155,3 +111,64 @@ export async function pMap(iterable, mapper, opt = {}) {
         }
     });
 }
+/**
+ pMap with serial (non-concurrent) execution.
+ */
+async function pMap1(items, mapper, errorMode, logger) {
+    let i = 0;
+    const ret = [];
+    const errors = [];
+    for (const item of items) {
+        try {
+            const r = await mapper(item, i++);
+            if (r === END)
+                break;
+            if (r !== SKIP)
+                ret.push(r);
+        }
+        catch (err) {
+            if (errorMode === ErrorMode.THROW_IMMEDIATELY)
+                throw err;
+            if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                errors.push(err);
+            }
+            else {
+                // otherwise, suppress (but still log via logger)
+                logger === null || logger === void 0 ? void 0 : logger.error(err);
+            }
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}
+/**
+ pMap with fully concurrent execution, like Promise.all
+ */
+async function pMapAll(items, mapper, errorMode, logger) {
+    if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+        return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== SKIP && r !== END);
+    }
+    const ret = [];
+    const errors = [];
+    for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
+        if (r.status === 'fulfilled') {
+            if (r.value === END)
+                break;
+            if (r.value !== SKIP)
+                ret.push(r.value);
+        }
+        else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+            errors.push(r.reason);
+        }
+        else {
+            // otherwise, suppress (but still log via logger)
+            logger === null || logger === void 0 ? void 0 : logger.error(r.reason);
+        }
+    }
+    if (errors.length) {
+        throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
+    }
+    return ret;
+}

package/dist-esm/string/leven.js

@@ -5,9 +5,12 @@ const characterCodeCache = [];
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-export function _leven(first, second) {
-    if (first === second) {
+export function _leven(first, second, limit) {
+    if (first === second || limit === 0) {
         return 0;
     }
     const swap = first;
@@ -37,6 +40,8 @@ export function _leven(first, second) {
     firstLength -= start;
     secondLength -= start;
     if (firstLength === 0) {
+        if (limit && secondLength >= limit)
+            return limit;
         return secondLength;
     }
     let bCharacterCode;
@@ -53,6 +58,8 @@ export function _leven(first, second) {
         bCharacterCode = second.charCodeAt(start + index2);
         temporary = index2++;
         result = index2;
+        if (limit && result >= limit)
+            return limit; // exit early on limit
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];

package/package.json

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

package/src/array/array.util.ts

@@ -229,19 +229,28 @@ export function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
 
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export function _count<T>(items: T[], predicate: AbortablePredicate<T>): number {
+export function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number {
+  if (limit === 0) return 0
   let count = 0
 
   for (const [i, item] of items.entries()) {
     const r = predicate(item, i)
     if (r === END) break
-    if (r) count++
+    if (r) {
+      count++
+      if (limit && count >= limit) break
+    }
   }
 
   return count
 }
 
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
 export function _countBy<T>(items: T[], mapper: Mapper<T, any>): StringMap<number> {
   const map: StringMap<number> = {}
 

package/src/promise/pMap.ts

@@ -1,12 +1,3 @@
-/*
-Taken from https://github.com/sindresorhus/p-map
-
-Improvements:
-- Exported as { pMap }, so IDE auto-completion works
-- Included Typescript typings (no need for @types/p-map)
-- Compatible with pProps (that had typings issues)
- */
-
 import type { AbortableAsyncMapper, CommonLogger } from '..'
 import { END, ErrorMode, SKIP } from '..'
 
@@ -14,7 +5,11 @@ export interface PMapOptions {
   /**
    * Number of concurrently pending promises returned by `mapper`.
    *
-   * @default Infinity
+   * Defaults to 16.
+   *
+   * It previously (and originally) defaulted to Infinity, which was later changed,
+   * because it's somewhat dangerous to run "infinite number of parallel promises".
+   * You can still emulate the old behavior by passing `Infinity`.
    */
   concurrency?: number
 
@@ -36,6 +31,14 @@ export interface PMapOptions {
 }
 
 /**
+ * Forked from https://github.com/sindresorhus/p-map
+ *
+ * Improvements:
+ * - Exported as { pMap }, so IDE auto-completion works
+ * - Included Typescript typings (no need for @types/p-map)
+ * - Compatible with pProps (that had typings issues)
+ * - Preserves async stack traces (in selected cases)
+ *
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
  * from `mapper` in `input` order.
@@ -66,73 +69,30 @@ export async function pMap<IN, OUT>(
   mapper: AbortableAsyncMapper<IN, OUT>,
   opt: PMapOptions = {},
 ): Promise<OUT[]> {
-  const { logger = console } = opt
-  const ret: (OUT | typeof SKIP)[] = []
-  // const iterator = iterable[Symbol.iterator]()
   const items = [...iterable]
   const itemsLength = items.length
   if (itemsLength === 0) return [] // short circuit
 
-  const { concurrency = itemsLength, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt
-
-  const errors: Error[] = []
-  let isSettled = false
-  let resolvingCount = 0
-  let currentIndex = 0
+  const { concurrency = 16, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt
 
   // Special cases that are able to preserve async stack traces
-
+  // Special case: serial execution
   if (concurrency === 1) {
-    // Special case for concurrency == 1
-
-    for (const item of items) {
-      try {
-        const r = await mapper(item, currentIndex++)
-        if (r === END) break
-        if (r !== SKIP) ret.push(r)
-      } catch (err) {
-        if (errorMode === ErrorMode.THROW_IMMEDIATELY) throw err
-        if (errorMode === ErrorMode.THROW_AGGREGATED) {
-          errors.push(err as Error)
-        } else {
-          // otherwise, suppress (but still log via logger)
-          logger?.error(err)
-        }
-      }
-    }
-
-    if (errors.length) {
-      throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
-    }
-
-    return ret as OUT[]
-  } else if (!opt.concurrency || items.length <= opt.concurrency) {
-    // Special case for concurrency == infinity or iterable.length < concurrency
-
-    if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
-      return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(
-        r => r !== SKIP && r !== END,
-      ) as OUT[]
-    }
-
-    ;(await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
-      if (r.status === 'fulfilled') {
-        if (r.value !== SKIP && r.value !== END) ret.push(r.value)
-      } else if (errorMode === ErrorMode.THROW_AGGREGATED) {
-        errors.push(r.reason)
-      } else {
-        // otherwise, suppress (but still log via logger)
-        logger?.error(r.reason)
-      }
-    })
-
-    if (errors.length) {
-      throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
-    }
+    return await pMap1(items, mapper, errorMode, logger)
+  }
 
-    return ret as OUT[]
+  // Special case: concurrency === Infinity or items.length <= concurrency
+  if (concurrency === Infinity || items.length <= concurrency) {
+    return await pMapAll(items, mapper, errorMode, logger)
   }
 
+  // General case: execution with throttled concurrency
+  const ret: (OUT | typeof SKIP)[] = []
+  const errors: Error[] = []
+  let isSettled = false
+  let resolvingCount = 0
+  let currentIndex = 0
+
   return await new Promise<OUT[]>((resolve, reject) => {
     const next = (): void => {
       if (isSettled) {
@@ -198,3 +158,76 @@ export async function pMap<IN, OUT>(
     }
   })
 }
+
+/**
+ pMap with serial (non-concurrent) execution.
+ */
+async function pMap1<IN, OUT>(
+  items: IN[],
+  mapper: AbortableAsyncMapper<IN, OUT>,
+  errorMode: ErrorMode,
+  logger: CommonLogger | null,
+): Promise<OUT[]> {
+  let i = 0
+  const ret: OUT[] = []
+  const errors: Error[] = []
+
+  for (const item of items) {
+    try {
+      const r = await mapper(item, i++)
+      if (r === END) break
+      if (r !== SKIP) ret.push(r)
+    } catch (err) {
+      if (errorMode === ErrorMode.THROW_IMMEDIATELY) throw err
+      if (errorMode === ErrorMode.THROW_AGGREGATED) {
+        errors.push(err as Error)
+      } else {
+        // otherwise, suppress (but still log via logger)
+        logger?.error(err)
+      }
+    }
+  }
+
+  if (errors.length) {
+    throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
+  }
+
+  return ret
+}
+
+/**
+ pMap with fully concurrent execution, like Promise.all
+ */
+async function pMapAll<IN, OUT>(
+  items: IN[],
+  mapper: AbortableAsyncMapper<IN, OUT>,
+  errorMode: ErrorMode,
+  logger: CommonLogger | null,
+): Promise<OUT[]> {
+  if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+    return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(
+      r => r !== SKIP && r !== END,
+    ) as OUT[]
+  }
+
+  const ret: OUT[] = []
+  const errors: Error[] = []
+
+  for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
+    if (r.status === 'fulfilled') {
+      if (r.value === END) break
+      if (r.value !== SKIP) ret.push(r.value)
+    } else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+      errors.push(r.reason)
+    } else {
+      // otherwise, suppress (but still log via logger)
+      logger?.error(r.reason)
+    }
+  }
+
+  if (errors.length) {
+    throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
+  }
+
+  return ret
+}

package/src/string/leven.ts

@@ -7,9 +7,12 @@ const characterCodeCache: number[] = []
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-export function _leven(first: string, second: string): number {
-  if (first === second) {
+export function _leven(first: string, second: string, limit?: number): number {
+  if (first === second || limit === 0) {
     return 0
   }
 
@@ -47,6 +50,7 @@ export function _leven(first: string, second: string): number {
   secondLength -= start
 
   if (firstLength === 0) {
+    if (limit && secondLength >= limit) return limit
     return secondLength
   }
 
@@ -66,6 +70,7 @@ export function _leven(first: string, second: string): number {
     bCharacterCode = second.charCodeAt(start + index2)
     temporary = index2++
     result = index2
+    if (limit && result >= limit) return limit // exit early on limit
 
     for (index = 0; index < firstLength; index++) {
       temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1