@naturalcycles/js-lib 15.93.1 → 15.93.3

package/dist/datetime/localTime.js

@@ -868,8 +868,7 @@ class LocalTimeFactory {
     isTimezoneValid(tz) {
         if (tz === 'UTC')
             return true; // we deliberately consider UTC a valid timezone, while it's mostly used in testing
-        // oxlint-disable-next-line no-restricted-globals
-        return Intl.supportedValuesOf('timeZone').includes(tz);
+        return Intl2.getSupportedTimezones().includes(tz);
     }
     sort(items, dir = 'asc', opt = {}) {
         const cmp = comparators.by((lt) => lt.$date.valueOf(), { dir });

package/dist/intl/intl.d.ts

@@ -7,13 +7,28 @@ import type { IANATimezone } from '../types.js';
  *
  * Methods accept non-optional arguments consciously,
  * to be able to cache them better. Just pass {} for options.
+ *
+ * The cache is never evicted, it grows with each unique combination of arguments.
+ * Don't pass unbounded dynamic values (e.g arbitrary user input) as locales or options.
  */
 declare class MemoizedIntl {
     /**
      * Returns the IANA timezone e.g `Europe/Stockholm`.
      * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+     *
+     * Memoized, so it returns the timezone at the time of the first call.
+     * Changing `process.env.TZ` at runtime after that is not reflected.
      */
     getTimezone(): IANATimezone;
+    /**
+     * Returns the list of IANA timezones supported by the runtime (~420 entries).
+     * Memoized, because V8 rebuilds the list on every call (~70µs).
+     *
+     * The list contains canonical CLDR ids only, so valid aliases are missing from it,
+     * e.g `UTC` and `Europe/Kyiv` (listed as `Europe/Kiev`).
+     * Don't use it to validate user input as is.
+     */
+    getSupportedTimezones(): readonly IANATimezone[];
     DateTimeFormat(locales: Intl.LocalesArgument, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
     RelativeTimeFormat(locales: Intl.LocalesArgument, options: Intl.RelativeTimeFormatOptions): Intl.RelativeTimeFormat;
     DurationFormat(locales: Intl.LocalesArgument, options: Intl.DurationFormatOptions): Intl.DurationFormat;

package/dist/intl/intl.js

@@ -9,15 +9,32 @@ import { _Memo } from '../decorators/memo.decorator.js';
  *
  * Methods accept non-optional arguments consciously,
  * to be able to cache them better. Just pass {} for options.
+ *
+ * The cache is never evicted, it grows with each unique combination of arguments.
+ * Don't pass unbounded dynamic values (e.g arbitrary user input) as locales or options.
  */
 class MemoizedIntl {
     /**
      * Returns the IANA timezone e.g `Europe/Stockholm`.
      * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+     *
+     * Memoized, so it returns the timezone at the time of the first call.
+     * Changing `process.env.TZ` at runtime after that is not reflected.
      */
     getTimezone() {
         return Intl.DateTimeFormat().resolvedOptions().timeZone;
     }
+    /**
+     * Returns the list of IANA timezones supported by the runtime (~420 entries).
+     * Memoized, because V8 rebuilds the list on every call (~70µs).
+     *
+     * The list contains canonical CLDR ids only, so valid aliases are missing from it,
+     * e.g `UTC` and `Europe/Kyiv` (listed as `Europe/Kiev`).
+     * Don't use it to validate user input as is.
+     */
+    getSupportedTimezones() {
+        return Intl.supportedValuesOf('timeZone');
+    }
     DateTimeFormat(locales, options) {
         return new Intl.DateTimeFormat(locales, options);
     }
@@ -51,29 +68,49 @@ __decorate([
 ], MemoizedIntl.prototype, "getTimezone", null);
 __decorate([
     _Memo()
+], MemoizedIntl.prototype, "getSupportedTimezones", null);
+__decorate([
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "DateTimeFormat", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "RelativeTimeFormat", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "DurationFormat", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "NumberFormat", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "Collator", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "PluralRules", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "ListFormat", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "DisplayNames", null);
 __decorate([
-    _Memo()
+    _Memo({ cacheKeyFn: intlCacheKeyFn })
 ], MemoizedIntl.prototype, "Segmenter", null);
 export const Intl2 = new MemoizedIntl();
+/**
+ * Default `jsonMemoSerializer` would serialize `Intl.Locale` instances as `{}`,
+ * making all Locale arguments share one cache key. Convert them to their string tags instead.
+ *
+ * Options keys are serialized in sorted order, so that `{ a, b }` and `{ b, a }` share one cache key.
+ * Passing a keys array as replacer works, because Intl options are flat objects.
+ */
+function intlCacheKeyFn([locales, options]) {
+    return JSON.stringify(localesKey(locales)) + JSON.stringify(options, Object.keys(options).sort());
+}
+function localesKey(locales) {
+    if (locales === undefined)
+        return;
+    if (Array.isArray(locales))
+        return locales.map(String);
+    return String(locales);
+}

package/dist/promise/pGradualQueue.d.ts

@@ -52,7 +52,13 @@ export declare class PGradualQueue {
      * Push PromiseReturningFunction to the Queue.
      * Returns a Promise that resolves (or rejects) with the return value from the Promise.
      */
-    push<R>(fn_: AsyncFunction<R>): Promise<R>;
+    push<R>(fn: AsyncFunction<R>): Promise<R>;
+    /**
+     * Starts the job and settles its `defer`.
+     * Intentionally not async: it's called both from `push` and when a running job finishes,
+     * and must not create a Promise that nobody handles (which would cause UnhandledRejection).
+     */
+    private start;
     get queueSize(): number;
     /**
      * Current concurrency limit based on warmup progress.

package/dist/promise/pGradualQueue.js

@@ -48,48 +48,55 @@ export class PGradualQueue {
      * Push PromiseReturningFunction to the Queue.
      * Returns a Promise that resolves (or rejects) with the return value from the Promise.
      */
-    async push(fn_) {
+    async push(fn) {
         // Initialize start time on first push
         if (this.startTime === 0) {
             this.startTime = Date.now();
         }
-        const { logger } = this;
-        const fn = fn_;
-        fn.defer ||= pDefer();
+        const job = { fn, defer: pDefer() };
         const concurrency = this.getCurrentConcurrency();
         if (this.inFlight < concurrency) {
-            this.inFlight++;
-            logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`);
-            runSafe(fn)
-                .then(result => {
-                fn.defer.resolve(result);
-            })
-                .catch((err) => {
-                if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
-                    logger.error(err);
-                    fn.defer.resolve(); // resolve with `void`
-                }
-                else {
-                    fn.defer.reject(err);
-                }
-            })
-                .finally(() => {
-                this.inFlight--;
-                const currentConcurrency = this.getCurrentConcurrency();
-                logger.debug(`inFlight-- ${this.inFlight}/${currentConcurrency}, queue ${this.queue.length}`);
-                // Start queued jobs up to the current concurrency limit
-                // Use while loop since concurrency may have increased during warmup
-                while (this.queue.length && this.inFlight < this.getCurrentConcurrency()) {
-                    const nextFn = this.queue.shift();
-                    void this.push(nextFn);
-                }
-            });
+            this.start(job, concurrency);
         }
         else {
-            this.queue.push(fn);
-            logger.debug(`inFlight ${this.inFlight}/${concurrency}, queue++ ${this.queue.length}`);
+            this.queue.push(job);
+            this.logger.debug(`inFlight ${this.inFlight}/${concurrency}, queue++ ${this.queue.length}`);
         }
-        return await fn.defer;
+        return await job.defer;
+    }
+    /**
+     * Starts the job and settles its `defer`.
+     * Intentionally not async: it's called both from `push` and when a running job finishes,
+     * and must not create a Promise that nobody handles (which would cause UnhandledRejection).
+     */
+    start(job, concurrency) {
+        const { logger } = this;
+        const { defer } = job;
+        this.inFlight++;
+        logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`);
+        runSafe(job.fn)
+            .then(result => {
+            defer.resolve(result);
+        })
+            .catch((err) => {
+            if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
+                logger.error(err);
+                defer.resolve(); // resolve with `void`
+            }
+            else {
+                defer.reject(err);
+            }
+        })
+            .finally(() => {
+            this.inFlight--;
+            const currentConcurrency = this.getCurrentConcurrency();
+            logger.debug(`inFlight-- ${this.inFlight}/${currentConcurrency}, queue ${this.queue.length}`);
+            // Start queued jobs up to the current concurrency limit
+            // Use while loop since concurrency may have increased during warmup
+            while (this.queue.length && this.inFlight < currentConcurrency) {
+                this.start(this.queue.shift(), currentConcurrency);
+            }
+        });
     }
     get queueSize() {
         return this.queue.length;

package/dist/promise/pQueue.d.ts

@@ -49,7 +49,13 @@ export declare class PQueue {
      * Push PromiseReturningFunction to the Queue.
      * Returns a Promise that resolves (or rejects) with the return value from the Promise.
      */
-    push<R>(fn_: AsyncFunction<R>): Promise<R>;
+    push<R>(fn: AsyncFunction<R>): Promise<R>;
+    /**
+     * Starts the job and settles its `defer`.
+     * Intentionally not async: it's called both from `push` and when a running job finishes,
+     * and must not create a Promise that nobody handles (which would cause UnhandledRejection).
+     */
+    private start;
     get queueSize(): number;
     /**
      * Returns a Promise that resolves when the queue is Idle (next time, since the call).

package/dist/promise/pQueue.js

@@ -28,59 +28,66 @@ export class PQueue {
      * Push PromiseReturningFunction to the Queue.
      * Returns a Promise that resolves (or rejects) with the return value from the Promise.
      */
-    async push(fn_) {
-        const { concurrency } = this.cfg;
-        const { resolveOnStart, logger } = this;
-        const fn = fn_;
-        fn.defer ||= pDefer();
-        if (this.inFlight < concurrency) {
+    async push(fn) {
+        const job = { fn, defer: pDefer() };
+        if (this.inFlight < this.cfg.concurrency) {
             // There is room for more jobs. Can start immediately
-            this.inFlight++;
-            logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`);
-            if (resolveOnStart)
-                fn.defer.resolve();
-            runSafe(fn)
-                .then(result => {
-                if (!resolveOnStart)
-                    fn.defer.resolve(result);
-            })
-                .catch((err) => {
-                if (resolveOnStart) {
-                    logger.error(err);
-                    return;
-                }
-                if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
-                    logger.error(err);
-                    fn.defer.resolve(); // resolve with `void`
-                }
-                else {
-                    // Should be handled on the outside, otherwise it'll cause UnhandledRejection
-                    // Not logging, because it's re-thrown upstream
-                    fn.defer.reject(err);
-                }
-            })
-                .finally(() => {
-                this.inFlight--;
-                logger.debug(`inFlight-- ${this.inFlight}/${concurrency}, queue ${this.queue.length}`);
-                // check if there's room to start next job
-                if (this.queue.length && this.inFlight <= concurrency) {
-                    const nextFn = this.queue.shift();
-                    void this.push(nextFn);
-                }
-                else {
-                    if (this.inFlight === 0) {
-                        logger.debug('onIdle');
-                        this.onIdleListeners.forEach(defer => defer.resolve());
-                        this.onIdleListeners.length = 0; // empty the array
-                    }
-                }
-            });
+            this.start(job);
         }
         else {
-            this.queue.push(fn);
-            logger.debug(`inFlight ${this.inFlight}/${concurrency}, queue++ ${this.queue.length}`);
+            this.queue.push(job);
+            this.logger.debug(`inFlight ${this.inFlight}/${this.cfg.concurrency}, queue++ ${this.queue.length}`);
         }
-        return await fn.defer;
+        return await job.defer;
+    }
+    /**
+     * Starts the job and settles its `defer`.
+     * Intentionally not async: it's called both from `push` and when a running job finishes,
+     * and must not create a Promise that nobody handles (which would cause UnhandledRejection).
+     */
+    start(job) {
+        const { concurrency } = this.cfg;
+        const { resolveOnStart, logger } = this;
+        const { defer } = job;
+        this.inFlight++;
+        logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`);
+        if (resolveOnStart)
+            defer.resolve();
+        runSafe(job.fn)
+            .then(result => {
+            if (!resolveOnStart)
+                defer.resolve(result);
+        })
+            .catch((err) => {
+            if (resolveOnStart) {
+                logger.error(err);
+                return;
+            }
+            if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
+                logger.error(err);
+                defer.resolve(); // resolve with `void`
+            }
+            else {
+                // Should be handled on the outside, otherwise it'll cause UnhandledRejection
+                // Not logging, because it's re-thrown upstream
+                defer.reject(err);
+            }
+        })
+            .finally(() => {
+            this.inFlight--;
+            logger.debug(`inFlight-- ${this.inFlight}/${concurrency}, queue ${this.queue.length}`);
+            // check if there's room to start next job
+            if (this.queue.length && this.inFlight < concurrency) {
+                this.start(this.queue.shift());
+            }
+            else {
+                if (this.inFlight === 0) {
+                    logger.debug('onIdle');
+                    this.onIdleListeners.forEach(defer => defer.resolve());
+                    this.onIdleListeners.length = 0; // empty the array
+                }
+            }
+        });
     }
     get queueSize() {
         return this.queue.length;

package/dist/semver.d.ts

@@ -16,6 +16,8 @@ export type SemverTokens = [major: number, minor: number, patch: number];
  *
  * _semver('1').toString() === '1.0.0'
  *
+ * 4-part strings are treated as equal to 3-part strings, e.g.: '1.2.3.4' === '1.2.3'
+ *
  * @experimental
  */
 export declare class Semver {

package/dist/semver.js

@@ -14,6 +14,8 @@ import { _assert } from './error/assert.js';
  *
  * _semver('1').toString() === '1.0.0'
  *
+ * 4-part strings are treated as equal to 3-part strings, e.g.: '1.2.3.4' === '1.2.3'
+ *
  * @experimental
  */
 export class Semver {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.93.1",
+  "version": "15.93.3",
   "dependencies": {
     "tslib": "^2"
   },

package/src/datetime/localTime.ts

@@ -1016,8 +1016,7 @@ class LocalTimeFactory {
    */
   isTimezoneValid(tz: string): boolean {
     if (tz === 'UTC') return true // we deliberately consider UTC a valid timezone, while it's mostly used in testing
-    // oxlint-disable-next-line no-restricted-globals
-    return Intl.supportedValuesOf('timeZone').includes(tz)
+    return Intl2.getSupportedTimezones().includes(tz as IANATimezone)
   }
 
   sort(items: LocalTime[], dir: SortDirection = 'asc', opt: MutateOptions = {}): LocalTime[] {

package/src/intl/intl.ts

@@ -1,5 +1,5 @@
 import { _Memo } from '../decorators/memo.decorator.js'
-import type { IANATimezone } from '../types.js'
+import type { AnyObject, IANATimezone } from '../types.js'
 
 // oxlint-disable no-restricted-globals
 
@@ -11,18 +11,37 @@ import type { IANATimezone } from '../types.js'
  *
  * Methods accept non-optional arguments consciously,
  * to be able to cache them better. Just pass {} for options.
+ *
+ * The cache is never evicted, it grows with each unique combination of arguments.
+ * Don't pass unbounded dynamic values (e.g arbitrary user input) as locales or options.
  */
 class MemoizedIntl {
   /**
    * Returns the IANA timezone e.g `Europe/Stockholm`.
    * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+   *
+   * Memoized, so it returns the timezone at the time of the first call.
+   * Changing `process.env.TZ` at runtime after that is not reflected.
    */
   @_Memo()
   getTimezone(): IANATimezone {
     return Intl.DateTimeFormat().resolvedOptions().timeZone as IANATimezone
   }
 
+  /**
+   * Returns the list of IANA timezones supported by the runtime (~420 entries).
+   * Memoized, because V8 rebuilds the list on every call (~70µs).
+   *
+   * The list contains canonical CLDR ids only, so valid aliases are missing from it,
+   * e.g `UTC` and `Europe/Kyiv` (listed as `Europe/Kiev`).
+   * Don't use it to validate user input as is.
+   */
   @_Memo()
+  getSupportedTimezones(): readonly IANATimezone[] {
+    return Intl.supportedValuesOf('timeZone') as IANATimezone[]
+  }
+
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   DateTimeFormat(
     locales: Intl.LocalesArgument,
     options: Intl.DateTimeFormatOptions,
@@ -30,7 +49,7 @@ class MemoizedIntl {
     return new Intl.DateTimeFormat(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   RelativeTimeFormat(
     locales: Intl.LocalesArgument,
     options: Intl.RelativeTimeFormatOptions,
@@ -38,7 +57,7 @@ class MemoizedIntl {
     return new Intl.RelativeTimeFormat(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   DurationFormat(
     locales: Intl.LocalesArgument,
     options: Intl.DurationFormatOptions,
@@ -46,7 +65,7 @@ class MemoizedIntl {
     return new Intl.DurationFormat(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   NumberFormat(
     locales: Intl.LocalesArgument,
     options: Intl.NumberFormatOptions,
@@ -54,22 +73,22 @@ class MemoizedIntl {
     return new Intl.NumberFormat(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   Collator(locales: Intl.LocalesArgument, options: Intl.CollatorOptions): Intl.Collator {
     return new Intl.Collator(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   PluralRules(locales: Intl.LocalesArgument, options: Intl.PluralRulesOptions): Intl.PluralRules {
     return new Intl.PluralRules(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   ListFormat(locales: Intl.LocalesArgument, options: Intl.ListFormatOptions): Intl.ListFormat {
     return new Intl.ListFormat(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   DisplayNames(
     locales: Intl.LocalesArgument,
     options: Intl.DisplayNamesOptions,
@@ -77,10 +96,27 @@ class MemoizedIntl {
     return new Intl.DisplayNames(locales, options)
   }
 
-  @_Memo()
+  @_Memo({ cacheKeyFn: intlCacheKeyFn })
   Segmenter(locales: Intl.LocalesArgument, options: Intl.SegmenterOptions): Intl.Segmenter {
     return new Intl.Segmenter(locales, options)
   }
 }
 
 export const Intl2 = new MemoizedIntl()
+
+/**
+ * Default `jsonMemoSerializer` would serialize `Intl.Locale` instances as `{}`,
+ * making all Locale arguments share one cache key. Convert them to their string tags instead.
+ *
+ * Options keys are serialized in sorted order, so that `{ a, b }` and `{ b, a }` share one cache key.
+ * Passing a keys array as replacer works, because Intl options are flat objects.
+ */
+function intlCacheKeyFn([locales, options]: [Intl.LocalesArgument, AnyObject]): string {
+  return JSON.stringify(localesKey(locales)) + JSON.stringify(options, Object.keys(options).sort())
+}
+
+function localesKey(locales: Intl.LocalesArgument): string | string[] | undefined {
+  if (locales === undefined) return
+  if (Array.isArray(locales)) return locales.map(String)
+  return String(locales)
+}

package/src/promise/pGradualQueue.ts

@@ -63,7 +63,7 @@ export class PGradualQueue {
   private warmupComplete: boolean
 
   inFlight = 0
-  private queue: AsyncFunction[] = []
+  private queue: PGradualQueueJob<any>[] = []
 
   /**
    * Get current allowed concurrency based on warmup progress.
@@ -89,54 +89,62 @@ export class PGradualQueue {
    * Push PromiseReturningFunction to the Queue.
    * Returns a Promise that resolves (or rejects) with the return value from the Promise.
    */
-  async push<R>(fn_: AsyncFunction<R>): Promise<R> {
+  async push<R>(fn: AsyncFunction<R>): Promise<R> {
     // Initialize start time on first push
     if (this.startTime === 0) {
       this.startTime = Date.now()
     }
 
-    const { logger } = this
-    const fn = fn_ as AsyncFunctionWithDefer<R>
-    fn.defer ||= pDefer<R>()
-
+    const job: PGradualQueueJob<R> = { fn, defer: pDefer<R>() }
     const concurrency = this.getCurrentConcurrency()
 
     if (this.inFlight < concurrency) {
-      this.inFlight++
-      logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`)
-
-      runSafe(fn)
-        .then(result => {
-          fn.defer.resolve(result)
-        })
-        .catch((err: Error) => {
-          if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
-            logger.error(err)
-            fn.defer.resolve() // resolve with `void`
-          } else {
-            fn.defer.reject(err)
-          }
-        })
-        .finally(() => {
-          this.inFlight--
-          const currentConcurrency = this.getCurrentConcurrency()
-          logger.debug(
-            `inFlight-- ${this.inFlight}/${currentConcurrency}, queue ${this.queue.length}`,
-          )
-
-          // Start queued jobs up to the current concurrency limit
-          // Use while loop since concurrency may have increased during warmup
-          while (this.queue.length && this.inFlight < this.getCurrentConcurrency()) {
-            const nextFn = this.queue.shift()!
-            void this.push(nextFn)
-          }
-        })
+      this.start(job, concurrency)
     } else {
-      this.queue.push(fn)
-      logger.debug(`inFlight ${this.inFlight}/${concurrency}, queue++ ${this.queue.length}`)
+      this.queue.push(job)
+      this.logger.debug(`inFlight ${this.inFlight}/${concurrency}, queue++ ${this.queue.length}`)
     }
 
-    return await fn.defer
+    return await job.defer
+  }
+
+  /**
+   * Starts the job and settles its `defer`.
+   * Intentionally not async: it's called both from `push` and when a running job finishes,
+   * and must not create a Promise that nobody handles (which would cause UnhandledRejection).
+   */
+  private start<R>(job: PGradualQueueJob<R>, concurrency: number): void {
+    const { logger } = this
+    const { defer } = job
+
+    this.inFlight++
+    logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`)
+
+    runSafe(job.fn)
+      .then(result => {
+        defer.resolve(result)
+      })
+      .catch((err: Error) => {
+        if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
+          logger.error(err)
+          defer.resolve() // resolve with `void`
+        } else {
+          defer.reject(err)
+        }
+      })
+      .finally(() => {
+        this.inFlight--
+        const currentConcurrency = this.getCurrentConcurrency()
+        logger.debug(
+          `inFlight-- ${this.inFlight}/${currentConcurrency}, queue ${this.queue.length}`,
+        )
+
+        // Start queued jobs up to the current concurrency limit
+        // Use while loop since concurrency may have increased during warmup
+        while (this.queue.length && this.inFlight < currentConcurrency) {
+          this.start(this.queue.shift()!, currentConcurrency)
+        }
+      })
   }
 
   get queueSize(): number {
@@ -164,6 +172,7 @@ function runSafe<R>(fn: AsyncFunction<R>): Promise<R> {
   }
 }
 
-interface AsyncFunctionWithDefer<R = unknown> extends AsyncFunction<R> {
+interface PGradualQueueJob<R> {
+  fn: AsyncFunction<R>
   defer: DeferredPromise<R>
 }

package/src/promise/pQueue.ts

@@ -61,67 +61,77 @@ export class PQueue {
   private readonly logger: CommonLogger
 
   inFlight = 0
-  private queue: AsyncFunction[] = []
+  private queue: PQueueJob<any>[] = []
   private onIdleListeners: DeferredPromise[] = []
 
   /**
    * Push PromiseReturningFunction to the Queue.
    * Returns a Promise that resolves (or rejects) with the return value from the Promise.
    */
-  async push<R>(fn_: AsyncFunction<R>): Promise<R> {
-    const { concurrency } = this.cfg
-    const { resolveOnStart, logger } = this
+  async push<R>(fn: AsyncFunction<R>): Promise<R> {
+    const job: PQueueJob<R> = { fn, defer: pDefer<R>() }
 
-    const fn = fn_ as AsyncFunctionWithDefer<R>
-    fn.defer ||= pDefer<R>()
-
-    if (this.inFlight < concurrency) {
+    if (this.inFlight < this.cfg.concurrency) {
       // There is room for more jobs. Can start immediately
-      this.inFlight++
-      logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`)
-      if (resolveOnStart) fn.defer.resolve()
-
-      runSafe(fn)
-        .then(result => {
-          if (!resolveOnStart) fn.defer.resolve(result)
-        })
-        .catch((err: Error) => {
-          if (resolveOnStart) {
-            logger.error(err)
-            return
-          }
-
-          if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
-            logger.error(err)
-            fn.defer.resolve() // resolve with `void`
-          } else {
-            // Should be handled on the outside, otherwise it'll cause UnhandledRejection
-            // Not logging, because it's re-thrown upstream
-            fn.defer.reject(err)
-          }
-        })
-        .finally(() => {
-          this.inFlight--
-          logger.debug(`inFlight-- ${this.inFlight}/${concurrency}, queue ${this.queue.length}`)
-
-          // check if there's room to start next job
-          if (this.queue.length && this.inFlight <= concurrency) {
-            const nextFn = this.queue.shift()!
-            void this.push(nextFn)
-          } else {
-            if (this.inFlight === 0) {
-              logger.debug('onIdle')
-              this.onIdleListeners.forEach(defer => defer.resolve())
-              this.onIdleListeners.length = 0 // empty the array
-            }
-          }
-        })
+      this.start(job)
     } else {
-      this.queue.push(fn)
-      logger.debug(`inFlight ${this.inFlight}/${concurrency}, queue++ ${this.queue.length}`)
+      this.queue.push(job)
+      this.logger.debug(
+        `inFlight ${this.inFlight}/${this.cfg.concurrency}, queue++ ${this.queue.length}`,
+      )
     }
 
-    return await fn.defer
+    return await job.defer
+  }
+
+  /**
+   * Starts the job and settles its `defer`.
+   * Intentionally not async: it's called both from `push` and when a running job finishes,
+   * and must not create a Promise that nobody handles (which would cause UnhandledRejection).
+   */
+  private start<R>(job: PQueueJob<R>): void {
+    const { concurrency } = this.cfg
+    const { resolveOnStart, logger } = this
+    const { defer } = job
+
+    this.inFlight++
+    logger.debug(`inFlight++ ${this.inFlight}/${concurrency}, queue ${this.queue.length}`)
+    if (resolveOnStart) defer.resolve()
+
+    runSafe(job.fn)
+      .then(result => {
+        if (!resolveOnStart) defer.resolve(result)
+      })
+      .catch((err: Error) => {
+        if (resolveOnStart) {
+          logger.error(err)
+          return
+        }
+
+        if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
+          logger.error(err)
+          defer.resolve() // resolve with `void`
+        } else {
+          // Should be handled on the outside, otherwise it'll cause UnhandledRejection
+          // Not logging, because it's re-thrown upstream
+          defer.reject(err)
+        }
+      })
+      .finally(() => {
+        this.inFlight--
+        logger.debug(`inFlight-- ${this.inFlight}/${concurrency}, queue ${this.queue.length}`)
+
+        // check if there's room to start next job
+        if (this.queue.length && this.inFlight < concurrency) {
+          this.start(this.queue.shift()!)
+        } else {
+          if (this.inFlight === 0) {
+            logger.debug('onIdle')
+            this.onIdleListeners.forEach(defer => defer.resolve())
+            this.onIdleListeners.length = 0 // empty the array
+          }
+        }
+      })
   }
 
   get queueSize(): number {
@@ -155,6 +165,7 @@ function runSafe<R>(fn: AsyncFunction<R>): Promise<R> {
   }
 }
 
-interface AsyncFunctionWithDefer<R> extends AsyncFunction<R> {
+interface PQueueJob<R> {
+  fn: AsyncFunction<R>
   defer: DeferredPromise<R>
 }

package/src/semver.ts

@@ -20,6 +20,8 @@ export type SemverTokens = [major: number, minor: number, patch: number]
  *
  * _semver('1').toString() === '1.0.0'
  *
+ * 4-part strings are treated as equal to 3-part strings, e.g.: '1.2.3.4' === '1.2.3'
+ *
  * @experimental
  */
 export class Semver {