@common.js/p-queue 8.0.1 → 9.3.2

package/dist/index.js

@@ -2,15 +2,34 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
         return PQueue;
+    },
+    PriorityQueue: function() {
+        return _priorityQueueJs.default;
+    },
+    TimeoutError: function() {
+        return _pTimeout.TimeoutError;
     }
 });
 var _eventemitter3 = require("eventemitter3");
 var _pTimeout = /*#__PURE__*/ _interopRequireWildcard(require("p-timeout"));
 var _priorityQueueJs = /*#__PURE__*/ _interopRequireDefault(require("./priority-queue.js"));
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
 function _assertThisInitialized(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -222,6 +241,12 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _objectSpread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -237,6 +262,30 @@ function _objectSpread(target) {
     }
     return target;
 }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _possibleConstructorReturn(self, call) {
     if (call && (_typeof(call) === "object" || typeof call === "function")) {
         return call;
@@ -250,10 +299,21 @@ function _setPrototypeOf(o, p) {
     };
     return _setPrototypeOf(o, p);
 }
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
 var _typeof = function(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
 function _isNativeReflectConstruct() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
@@ -373,10 +433,14 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
         };
     }
 };
-var _carryoverConcurrencyCount = /*#__PURE__*/ new WeakMap(), _isIntervalIgnored = /*#__PURE__*/ new WeakMap(), _intervalCount = /*#__PURE__*/ new WeakMap(), _intervalCap = /*#__PURE__*/ new WeakMap(), _interval = /*#__PURE__*/ new WeakMap(), _intervalEnd = /*#__PURE__*/ new WeakMap(), _intervalId = /*#__PURE__*/ new WeakMap(), _timeoutId = /*#__PURE__*/ new WeakMap(), _queue = /*#__PURE__*/ new WeakMap(), _queueClass = /*#__PURE__*/ new WeakMap(), _pending = /*#__PURE__*/ new WeakMap(), // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
-_concurrency = /*#__PURE__*/ new WeakMap(), _isPaused = /*#__PURE__*/ new WeakMap(), _throwOnTimeout = /*#__PURE__*/ new WeakMap(), _doesIntervalAllowAnother = /*#__PURE__*/ new WeakMap(), _doesConcurrentAllowAnother = /*#__PURE__*/ new WeakMap(), _next = /*#__PURE__*/ new WeakSet(), _onResumeInterval = /*#__PURE__*/ new WeakSet(), _isIntervalPaused = /*#__PURE__*/ new WeakMap(), _tryToStartAnother = /*#__PURE__*/ new WeakSet(), _initializeIntervalIfNeeded = /*#__PURE__*/ new WeakSet(), _onInterval = /*#__PURE__*/ new WeakSet(), /**
+var _carryoverIntervalCount = /*#__PURE__*/ new WeakMap(), _isIntervalIgnored = /*#__PURE__*/ new WeakMap(), _intervalCount = /*#__PURE__*/ new WeakMap(), _intervalCap = /*#__PURE__*/ new WeakMap(), _rateLimitedInInterval = /*#__PURE__*/ new WeakMap(), _rateLimitFlushScheduled = /*#__PURE__*/ new WeakMap(), _interval = /*#__PURE__*/ new WeakMap(), _intervalEnd = /*#__PURE__*/ new WeakMap(), _lastExecutionTime = /*#__PURE__*/ new WeakMap(), _intervalId = /*#__PURE__*/ new WeakMap(), _timeoutId = /*#__PURE__*/ new WeakMap(), _strict = /*#__PURE__*/ new WeakMap(), // Circular buffer implementation for better performance
+_strictTicks = /*#__PURE__*/ new WeakMap(), _strictTicksStartIndex = /*#__PURE__*/ new WeakMap(), _queue = /*#__PURE__*/ new WeakMap(), _queueClass = /*#__PURE__*/ new WeakMap(), _pending = /*#__PURE__*/ new WeakMap(), // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+_concurrency = /*#__PURE__*/ new WeakMap(), _isPaused = /*#__PURE__*/ new WeakMap(), // Use to assign a unique identifier to a promise function, if not explicitly specified
+_idAssigner = /*#__PURE__*/ new WeakMap(), // Track currently running tasks for debugging
+_runningTasks = /*#__PURE__*/ new WeakMap(), _queueAbortListenerCleanupFunctions = /*#__PURE__*/ new WeakMap(), _cleanupStrictTicks = /*#__PURE__*/ new WeakSet(), // Helper methods for interval consumption
+_consumeIntervalSlot = /*#__PURE__*/ new WeakSet(), _rollbackIntervalSlot = /*#__PURE__*/ new WeakSet(), _getActiveTicksCount = /*#__PURE__*/ new WeakSet(), _doesIntervalAllowAnother = /*#__PURE__*/ new WeakMap(), _doesConcurrentAllowAnother = /*#__PURE__*/ new WeakMap(), _next = /*#__PURE__*/ new WeakSet(), _onResumeInterval = /*#__PURE__*/ new WeakSet(), _isIntervalPausedAt = /*#__PURE__*/ new WeakSet(), _createIntervalTimeout = /*#__PURE__*/ new WeakSet(), _clearIntervalTimer = /*#__PURE__*/ new WeakSet(), _clearTimeoutTimer = /*#__PURE__*/ new WeakSet(), _tryToStartAnother = /*#__PURE__*/ new WeakSet(), _initializeIntervalIfNeeded = /*#__PURE__*/ new WeakSet(), _onInterval = /*#__PURE__*/ new WeakSet(), /**
     Executes all queued functions until it reaches the limit.
-    */ _processQueue = /*#__PURE__*/ new WeakSet(), _throwOnAbort = /*#__PURE__*/ new WeakSet(), _onEvent = /*#__PURE__*/ new WeakSet();
+    */ _processQueue = /*#__PURE__*/ new WeakSet(), _onEvent = /*#__PURE__*/ new WeakSet(), _setupRateLimitTracking = /*#__PURE__*/ new WeakSet(), _scheduleRateLimitUpdate = /*#__PURE__*/ new WeakSet(), _rollbackIntervalConsumption = /*#__PURE__*/ new WeakSet(), _updateRateLimitState = /*#__PURE__*/ new WeakSet();
 var PQueue = /*#__PURE__*/ function(EventEmitter) {
     "use strict";
     _inherits(PQueue, EventEmitter);
@@ -385,6 +449,10 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
         _classCallCheck(this, PQueue);
         var _this;
         _this = _super.call(this);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _cleanupStrictTicks);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _consumeIntervalSlot);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _rollbackIntervalSlot);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _getActiveTicksCount);
         _classPrivateFieldInit(_assertThisInitialized(_this), _doesIntervalAllowAnother, {
             get: get_doesIntervalAllowAnother,
             set: void 0
@@ -395,17 +463,20 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
         });
         _classPrivateMethodInit(_assertThisInitialized(_this), _next);
         _classPrivateMethodInit(_assertThisInitialized(_this), _onResumeInterval);
-        _classPrivateFieldInit(_assertThisInitialized(_this), _isIntervalPaused, {
-            get: get_isIntervalPaused,
-            set: void 0
-        });
+        _classPrivateMethodInit(_assertThisInitialized(_this), _isIntervalPausedAt);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _createIntervalTimeout);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _clearIntervalTimer);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _clearTimeoutTimer);
         _classPrivateMethodInit(_assertThisInitialized(_this), _tryToStartAnother);
         _classPrivateMethodInit(_assertThisInitialized(_this), _initializeIntervalIfNeeded);
         _classPrivateMethodInit(_assertThisInitialized(_this), _onInterval);
         _classPrivateMethodInit(_assertThisInitialized(_this), _processQueue);
-        _classPrivateMethodInit(_assertThisInitialized(_this), _throwOnAbort);
         _classPrivateMethodInit(_assertThisInitialized(_this), _onEvent);
-        _classPrivateFieldInit(_assertThisInitialized(_this), _carryoverConcurrencyCount, {
+        _classPrivateMethodInit(_assertThisInitialized(_this), _setupRateLimitTracking);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _scheduleRateLimitUpdate);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _rollbackIntervalConsumption);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _updateRateLimitState);
+        _classPrivateFieldInit(_assertThisInitialized(_this), _carryoverIntervalCount, {
             writable: true,
             value: void 0
         });
@@ -421,6 +492,14 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
             writable: true,
             value: void 0
         });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _rateLimitedInInterval, {
+            writable: true,
+            value: false
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _rateLimitFlushScheduled, {
+            writable: true,
+            value: false
+        });
         _classPrivateFieldInit(_assertThisInitialized(_this), _interval, {
             writable: true,
             value: void 0
@@ -429,6 +508,10 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
             writable: true,
             value: 0
         });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _lastExecutionTime, {
+            writable: true,
+            value: 0
+        });
         _classPrivateFieldInit(_assertThisInitialized(_this), _intervalId, {
             writable: true,
             value: void 0
@@ -437,6 +520,18 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
             writable: true,
             value: void 0
         });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _strict, {
+            writable: true,
+            value: void 0
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _strictTicks, {
+            writable: true,
+            value: []
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _strictTicksStartIndex, {
+            writable: true,
+            value: 0
+        });
         _classPrivateFieldInit(_assertThisInitialized(_this), _queue, {
             writable: true,
             value: void 0
@@ -457,23 +552,42 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
             writable: true,
             value: void 0
         });
-        _classPrivateFieldInit(_assertThisInitialized(_this), _throwOnTimeout, {
+        _classPrivateFieldInit(_assertThisInitialized(_this), _idAssigner, {
             writable: true,
-            value: void 0
+            value: 1n
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _runningTasks, {
+            writable: true,
+            value: new Map()
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _queueAbortListenerCleanupFunctions, {
+            writable: true,
+            value: new Set()
         });
         /**
-    Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    Get or set the default timeout for all tasks. Can be changed at runtime.
+
+    Operations will throw a `TimeoutError` if they don't complete within the specified time.
+
+    The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+
+    @example
+    ```
+    const queue = new PQueue({timeout: 5000});
 
-    Applies to each future operation.
+    // Change timeout for all future tasks
+    queue.timeout = 10000;
+    ```
     */ _defineProperty(_assertThisInitialized(_this), "timeout", void 0);
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         options = _objectSpread({
-            carryoverConcurrencyCount: false,
+            carryoverIntervalCount: false,
             intervalCap: Number.POSITIVE_INFINITY,
             interval: 0,
             concurrency: Number.POSITIVE_INFINITY,
             autoStart: true,
-            queueClass: _priorityQueueJs.default
+            queueClass: _priorityQueueJs.default,
+            strict: false
         }, options);
         if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
             var ref;
@@ -485,16 +599,27 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
             var ref3;
             throw new TypeError("Expected `interval` to be a finite number >= 0, got `".concat((ref3 = (ref2 = options.interval) === null || ref2 === void 0 ? void 0 : ref2.toString()) !== null && ref3 !== void 0 ? ref3 : "", "` (").concat(_typeof(options.interval), ")"));
         }
-        _classPrivateFieldSet(_assertThisInitialized(_this), _carryoverConcurrencyCount, options.carryoverConcurrencyCount);
+        if (options.strict && options.interval === 0) {
+            throw new TypeError("The `strict` option requires a non-zero `interval`");
+        }
+        if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+            throw new TypeError("The `strict` option requires a finite `intervalCap`");
+        }
+        var _carryoverIntervalCount1, ref4;
+        _classPrivateFieldSet(_assertThisInitialized(_this), _carryoverIntervalCount, (ref4 = (_carryoverIntervalCount1 = options.carryoverIntervalCount) !== null && _carryoverIntervalCount1 !== void 0 ? _carryoverIntervalCount1 : options.carryoverConcurrencyCount) !== null && ref4 !== void 0 ? ref4 : false);
         _classPrivateFieldSet(_assertThisInitialized(_this), _isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0);
         _classPrivateFieldSet(_assertThisInitialized(_this), _intervalCap, options.intervalCap);
         _classPrivateFieldSet(_assertThisInitialized(_this), _interval, options.interval);
+        _classPrivateFieldSet(_assertThisInitialized(_this), _strict, options.strict);
         _classPrivateFieldSet(_assertThisInitialized(_this), _queue, new options.queueClass());
         _classPrivateFieldSet(_assertThisInitialized(_this), _queueClass, options.queueClass);
         _this.concurrency = options.concurrency;
+        if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+            throw new TypeError("Expected `timeout` to be a positive finite number, got `".concat(options.timeout, "` (").concat(_typeof(options.timeout), ")"));
+        }
         _this.timeout = options.timeout;
-        _classPrivateFieldSet(_assertThisInitialized(_this), _throwOnTimeout, options.throwOnTimeout === true);
         _classPrivateFieldSet(_assertThisInitialized(_this), _isPaused, options.autoStart === false);
+        _classPrivateMethodGet(_this, _setupRateLimitTracking, setupRateLimitTracking).call(_assertThisInitialized(_this));
         return _this;
     }
     _createClass(PQueue, [
@@ -511,88 +636,210 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
                 _classPrivateMethodGet(this, _processQueue, processQueue).call(this);
             }
         },
+        {
+            /**
+    Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+
+    For example, this can be used to prioritize a promise function to run earlier.
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 1});
+
+    queue.add(async () => '🦄', {priority: 1});
+    queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+    queue.add(async () => '🦄', {priority: 1});
+    queue.add(async () => '🦄', {priority: 1});
+
+    queue.setPriority('🦀', 2);
+    ```
+
+    In this case, the promise function with `id: '🦀'` runs second.
+
+    You can also deprioritize a promise function to delay its execution:
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 1});
+
+    queue.add(async () => '🦄', {priority: 1});
+    queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+    queue.add(async () => '🦄');
+    queue.add(async () => '🦄', {priority: 0});
+
+    queue.setPriority('🦀', -1);
+    ```
+    Here, the promise function with `id: '🦀'` executes last.
+    */ key: "setPriority",
+            value: function setPriority(id, priority) {
+                if (typeof priority !== "number" || !Number.isFinite(priority)) {
+                    throw new TypeError("Expected `priority` to be a finite number, got `".concat(priority, "` (").concat(typeof priority === "undefined" ? "undefined" : _typeof(priority), ")"));
+                }
+                _classPrivateFieldGet(this, _queue).setPriority(id, priority);
+            }
+        },
         {
             key: "add",
             value: function add(function_) {
                 var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
                 var _this = this;
                 return _asyncToGenerator(function() {
+                    var _id;
                     return __generator(this, function(_state) {
-                        options = _objectSpread({
-                            timeout: _this.timeout,
-                            throwOnTimeout: _classPrivateFieldGet(_this, _throwOnTimeout)
-                        }, options);
+                        // Create a copy to avoid mutating the original options object
+                        options = _objectSpreadProps(_objectSpread({
+                            timeout: _this.timeout
+                        }, options), {
+                            // Assign unique ID if not provided
+                            id: (_id = options.id) !== null && _id !== void 0 ? _id : (_classPrivateFieldUpdate(_this, _idAssigner).value++).toString()
+                        });
                         return [
                             2,
                             new Promise(function(resolve, reject) {
-                                _classPrivateFieldGet(_this, _queue).enqueue(/*#__PURE__*/ _asyncToGenerator(function() {
-                                    var ref, operation, result, error;
-                                    return __generator(this, function(_state) {
-                                        switch(_state.label){
-                                            case 0:
-                                                _classPrivateFieldUpdate(_this, _pending).value++;
-                                                _classPrivateFieldUpdate(_this, _intervalCount).value++;
-                                                _state.label = 1;
-                                            case 1:
-                                                _state.trys.push([
-                                                    1,
-                                                    3,
-                                                    4,
-                                                    5
-                                                ]);
-                                                (ref = options.signal) === null || ref === void 0 ? void 0 : ref.throwIfAborted();
-                                                operation = function_({
-                                                    signal: options.signal
-                                                });
-                                                if (options.timeout) {
-                                                    operation = (0, _pTimeout.default)(Promise.resolve(operation), {
-                                                        milliseconds: options.timeout
+                                // Create a unique symbol for tracking this task
+                                var taskSymbol = Symbol("task-".concat(options.id));
+                                var cleanupQueueAbortHandler = function() {
+                                    return undefined;
+                                };
+                                var run = function() {
+                                    var _ref = _asyncToGenerator(function() {
+                                        var _priority, eventListener, ref, operation, signal, result, error, ref1;
+                                        return __generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    // Task is now running — remove the queued-state abort listener
+                                                    cleanupQueueAbortHandler();
+                                                    _classPrivateFieldUpdate(_this, _pending).value++;
+                                                    // Track this running task
+                                                    _classPrivateFieldGet(_this, _runningTasks).set(taskSymbol, {
+                                                        id: options.id,
+                                                        priority: (_priority = options.priority) !== null && _priority !== void 0 ? _priority : 0,
+                                                        startTime: Date.now(),
+                                                        timeout: options.timeout
                                                     });
-                                                }
-                                                if (options.signal) {
-                                                    operation = Promise.race([
-                                                        operation,
-                                                        _classPrivateMethodGet(_this, _throwOnAbort, throwOnAbort).call(_this, options.signal)
+                                                    _state.label = 1;
+                                                case 1:
+                                                    _state.trys.push([
+                                                        1,
+                                                        3,
+                                                        4,
+                                                        5
                                                     ]);
-                                                }
-                                                return [
-                                                    4,
-                                                    operation
-                                                ];
-                                            case 2:
-                                                result = _state.sent();
-                                                resolve(result);
-                                                _this.emit("completed", result);
-                                                return [
-                                                    3,
-                                                    5
-                                                ];
-                                            case 3:
-                                                error = _state.sent();
-                                                if (_instanceof(error, _pTimeout.TimeoutError) && !options.throwOnTimeout) {
-                                                    resolve();
+                                                    // Check abort signal - if aborted, need to decrement the counter
+                                                    // that was incremented in tryToStartAnother
+                                                    try {
+                                                        ;
+                                                        (ref = options.signal) === null || ref === void 0 ? void 0 : ref.throwIfAborted();
+                                                    } catch (error1) {
+                                                        _classPrivateMethodGet(_this, _rollbackIntervalConsumption, rollbackIntervalConsumption).call(_this);
+                                                        // Clean up tracking before throwing
+                                                        _classPrivateFieldGet(_this, _runningTasks).delete(taskSymbol);
+                                                        throw error1;
+                                                    }
+                                                    _classPrivateFieldSet(_this, _lastExecutionTime, Date.now());
+                                                    operation = function_({
+                                                        signal: options.signal
+                                                    });
+                                                    if (options.timeout) {
+                                                        operation = (0, _pTimeout.default)(Promise.resolve(operation), {
+                                                            milliseconds: options.timeout,
+                                                            message: "Task timed out after ".concat(options.timeout, "ms (queue has ").concat(_classPrivateFieldGet(_this, _pending), " running, ").concat(_classPrivateFieldGet(_this, _queue).size, " waiting)")
+                                                        });
+                                                    }
+                                                    if (options.signal) {
+                                                        signal = options.signal;
+                                                        operation = Promise.race([
+                                                            operation,
+                                                            new Promise(function(_resolve, reject) {
+                                                                eventListener = function() {
+                                                                    reject(signal.reason);
+                                                                };
+                                                                signal.addEventListener("abort", eventListener, {
+                                                                    once: true
+                                                                });
+                                                            })
+                                                        ]);
+                                                    }
+                                                    return [
+                                                        4,
+                                                        operation
+                                                    ];
+                                                case 2:
+                                                    result = _state.sent();
+                                                    resolve(result);
+                                                    _this.emit("completed", result);
+                                                    return [
+                                                        3,
+                                                        5
+                                                    ];
+                                                case 3:
+                                                    error = _state.sent();
+                                                    reject(error);
+                                                    _this.emit("error", error);
+                                                    return [
+                                                        3,
+                                                        5
+                                                    ];
+                                                case 4:
+                                                    // Clean up abort event listener
+                                                    if (eventListener) {
+                                                        ;
+                                                        (ref1 = options.signal) === null || ref1 === void 0 ? void 0 : ref1.removeEventListener("abort", eventListener);
+                                                    }
+                                                    // Remove from running tasks
+                                                    _classPrivateFieldGet(_this, _runningTasks).delete(taskSymbol);
+                                                    // Use queueMicrotask to prevent deep recursion while maintaining timing
+                                                    queueMicrotask(function() {
+                                                        _classPrivateMethodGet(_this, _next, next).call(_this);
+                                                    });
+                                                    return [
+                                                        7
+                                                    ];
+                                                case 5:
                                                     return [
                                                         2
                                                     ];
-                                                }
-                                                reject(error);
-                                                _this.emit("error", error);
-                                                return [
-                                                    3,
-                                                    5
-                                                ];
-                                            case 4:
-                                                _classPrivateMethodGet(_this, _next, next).call(_this);
-                                                return [
-                                                    7
-                                                ];
-                                            case 5:
-                                                return [
-                                                    2
-                                                ];
-                                        }
+                                            }
+                                        });
+                                    });
+                                    return function run() {
+                                        return _ref.apply(this, arguments);
+                                    };
+                                }();
+                                _classPrivateFieldGet(_this, _queue).enqueue(run, options);
+                                var removeQueuedTask = function() {
+                                    var _obj, ref;
+                                    if (_instanceof(_classPrivateFieldGet(_this, _queue), _priorityQueueJs.default)) {
+                                        _classPrivateFieldGet(_this, _queue).remove(run);
+                                        return;
+                                    }
+                                    (ref = (_obj = _classPrivateFieldGet(_this, _queue)).remove) === null || ref === void 0 ? void 0 : ref.call(_obj, options.id); // Intentionally best-effort: queued abort removal is only supported for queue classes that implement `.remove()`.
+                                };
+                                // Handle abort while task is waiting in the queue
+                                if (options.signal) {
+                                    var signal = options.signal;
+                                    var queueAbortHandler = function() {
+                                        cleanupQueueAbortHandler();
+                                        removeQueuedTask();
+                                        reject(signal.reason);
+                                        _classPrivateMethodGet(_this, _tryToStartAnother, tryToStartAnother).call(_this);
+                                        _this.emit("next");
+                                    };
+                                    cleanupQueueAbortHandler = function() {
+                                        signal.removeEventListener("abort", queueAbortHandler);
+                                        _classPrivateFieldGet(_this, _queueAbortListenerCleanupFunctions).delete(cleanupQueueAbortHandler);
+                                    };
+                                    if (signal.aborted) {
+                                        queueAbortHandler();
+                                        return;
+                                    }
+                                    signal.addEventListener("abort", queueAbortHandler, {
+                                        once: true
                                     });
-                                }), options);
+                                    _classPrivateFieldGet(_this, _queueAbortListenerCleanupFunctions).add(cleanupQueueAbortHandler);
+                                }
                                 _this.emit("add");
                                 _classPrivateMethodGet(_this, _tryToStartAnother, tryToStartAnother).call(_this);
                             })
@@ -653,7 +900,43 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
     Clear the queue.
     */ key: "clear",
             value: function clear() {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = _classPrivateFieldGet(this, _queueAbortListenerCleanupFunctions)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var cleanupQueueAbortHandler = _step.value;
+                        cleanupQueueAbortHandler();
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
                 _classPrivateFieldSet(this, _queue, new (_classPrivateFieldGet(this, _queueClass))());
+                // Clear interval timer since queue is now empty (consistent with #tryToStartAnother)
+                _classPrivateMethodGet(this, _clearIntervalTimer, clearIntervalTimer).call(this);
+                // Note: We preserve strict mode rate-limiting state (ticks and timeout)
+                // because clear() only clears queued tasks, not rate limit history.
+                // This ensures that rate limits are still enforced after clearing the queue.
+                // Note: We don't clear #runningTasks as those tasks are still running
+                // They will be removed when they complete in the finally block
+                // Force synchronous update since clear() should have immediate effect
+                _classPrivateMethodGet(this, _updateRateLimitState, updateRateLimitState).call(this);
+                // Emit events so waiters (onEmpty, onIdle, onSizeLessThan) can resolve
+                this.emit("empty");
+                if (_classPrivateFieldGet(this, _pending) === 0) {
+                    _classPrivateMethodGet(this, _clearTimeoutTimer, clearTimeoutTimer).call(this);
+                    this.emit("idle");
+                }
+                this.emit("next");
             }
         },
         {
@@ -702,15 +985,21 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
                     return __generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                // Instantly resolve if the queue is empty.
+                                // Instantly resolve if the size is already below the limit.
                                 if (_classPrivateFieldGet(_this, _queue).size < limit) {
                                     return [
                                         2
                                     ];
                                 }
+                                // Listen on both `'next'` (task completion, queued abort, `clear()`) and `'active'` (every dequeue),
+                                // so waiters wake even when the queue drains without a completion (`start()`, a runtime `concurrency`
+                                // increase, or an interval tick).
                                 return [
                                     4,
-                                    _classPrivateMethodGet(_this, _onEvent, onEvent).call(_this, "next", function() {
+                                    _classPrivateMethodGet(_this, _onEvent, onEvent).call(_this, [
+                                        "next",
+                                        "active"
+                                    ], function() {
                                         return _classPrivateFieldGet(_this, _queue).size < limit;
                                     })
                                 ];
@@ -756,6 +1045,137 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
                 })();
             }
         },
+        {
+            key: "onPendingZero",
+            value: /**
+    The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+
+    @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+    */ function onPendingZero() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (_classPrivateFieldGet(_this, _pending) === 0) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    _classPrivateMethodGet(_this, _onEvent, onEvent).call(_this, "pendingZero")
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "onRateLimit",
+            value: /**
+    @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+    */ function onRateLimit() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (_this.isRateLimited) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    _classPrivateMethodGet(_this, _onEvent, onEvent).call(_this, "rateLimit")
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "onRateLimitCleared",
+            value: /**
+    @returns A promise that settles when the queue is no longer rate-limited.
+    */ function onRateLimitCleared() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!_this.isRateLimited) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    _classPrivateMethodGet(_this, _onEvent, onEvent).call(_this, "rateLimitCleared")
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            /**
+    @returns A promise that rejects when any task in the queue errors.
+
+    Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+
+    Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+
+    @example
+    ```
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 2});
+
+    queue.add(() => fetchData(1)).catch(() => {});
+    queue.add(() => fetchData(2)).catch(() => {});
+    queue.add(() => fetchData(3)).catch(() => {});
+
+    // Stop processing on first error
+    try {
+        await Promise.race([
+            queue.onError(),
+            queue.onIdle()
+        ]);
+    } catch (error) {
+        queue.pause(); // Stop processing remaining tasks
+        console.error('Queue failed:', error);
+    }
+    ```
+    */ // eslint-disable-next-line @typescript-eslint/promise-function-async
+            key: "onError",
+            value: function onError() {
+                var _this = this;
+                return new Promise(function(_resolve, reject) {
+                    var handleError = function(error) {
+                        _this.off("error", handleError);
+                        reject(error);
+                    };
+                    _this.on("error", handleError);
+                });
+            }
+        },
         {
             key: "size",
             get: /**
@@ -790,126 +1210,292 @@ var PQueue = /*#__PURE__*/ function(EventEmitter) {
     */ function get() {
                 return _classPrivateFieldGet(this, _isPaused);
             }
+        },
+        {
+            key: "isRateLimited",
+            get: /**
+    Whether the queue is currently rate-limited due to intervalCap.
+    */ function get() {
+                return _classPrivateFieldGet(this, _rateLimitedInInterval);
+            }
+        },
+        {
+            key: "isSaturated",
+            get: /**
+    Whether the queue is saturated. Returns `true` when:
+    - All concurrency slots are occupied and tasks are waiting, OR
+    - The queue is rate-limited and tasks are waiting
+
+    Useful for detecting backpressure and potential hanging tasks.
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 2});
+
+    // Backpressure handling
+    if (queue.isSaturated) {
+        console.log('Queue is saturated, waiting for capacity...');
+        await queue.onSizeLessThan(queue.concurrency);
+    }
+
+    // Monitoring for stuck tasks
+    setInterval(() => {
+        if (queue.isSaturated) {
+            console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+        }
+    }, 60000);
+    ```
+    */ function get() {
+                return _classPrivateFieldGet(this, _pending) === _classPrivateFieldGet(this, _concurrency) && _classPrivateFieldGet(this, _queue).size > 0 || this.isRateLimited && _classPrivateFieldGet(this, _queue).size > 0;
+            }
+        },
+        {
+            key: "runningTasks",
+            get: /**
+    The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, `timeout` (if set), and `timeoutRemaining` (milliseconds until the task times out, or `undefined` if no timeout is set).
+
+    Returns an array of task info objects.
+
+    ```js
+    import PQueue from 'p-queue';
+
+    const queue = new PQueue({concurrency: 2, timeout: 10000});
+
+    // Add tasks with IDs for better debugging
+    queue.add(() => fetchUser(123), {id: 'user-123'});
+    queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+
+    // Check what's running
+    console.log(queue.runningTasks);
+    // => [{
+    //   id: 'user-123',
+    //   priority: 0,
+    //   startTime: 1759253001716,
+    //   timeout: 10000,
+    //   timeoutRemaining: 9700
+    // }, {
+    //   id: 'posts-456',
+    //   priority: 1,
+    //   startTime: 1759253001916,
+    //   timeout: 10000,
+    //   timeoutRemaining: 9900
+    // }]
+    ```
+    */ function get() {
+                // Return fresh array with fresh objects to prevent mutations
+                return _toConsumableArray(_classPrivateFieldGet(this, _runningTasks).values()).map(function(task) {
+                    return _objectSpreadProps(_objectSpread({}, task), {
+                        timeoutRemaining: task.timeout ? Math.max(0, task.startTime + task.timeout - Date.now()) : undefined
+                    });
+                });
+            }
         }
     ]);
     return PQueue;
 }(_eventemitter3.EventEmitter);
+function cleanupStrictTicks(now) {
+    // Remove ticks outside the current interval window using circular buffer approach
+    while(_classPrivateFieldGet(this, _strictTicksStartIndex) < _classPrivateFieldGet(this, _strictTicks).length){
+        var oldestTick = _classPrivateFieldGet(this, _strictTicks)[_classPrivateFieldGet(this, _strictTicksStartIndex)];
+        if (oldestTick !== undefined && now - oldestTick >= _classPrivateFieldGet(this, _interval)) {
+            _classPrivateFieldUpdate(this, _strictTicksStartIndex).value++;
+        } else {
+            break;
+        }
+    }
+    // Compact the array when it becomes inefficient or fully consumed
+    // Compact when: (start index is large AND more than half wasted) OR all ticks expired
+    var shouldCompact = _classPrivateFieldGet(this, _strictTicksStartIndex) > 100 && _classPrivateFieldGet(this, _strictTicksStartIndex) > _classPrivateFieldGet(this, _strictTicks).length / 2 || _classPrivateFieldGet(this, _strictTicksStartIndex) === _classPrivateFieldGet(this, _strictTicks).length;
+    if (shouldCompact) {
+        _classPrivateFieldSet(this, _strictTicks, _classPrivateFieldGet(this, _strictTicks).slice(_classPrivateFieldGet(this, _strictTicksStartIndex)));
+        _classPrivateFieldSet(this, _strictTicksStartIndex, 0);
+    }
+}
+function consumeIntervalSlot(now) {
+    if (_classPrivateFieldGet(this, _strict)) {
+        _classPrivateFieldGet(this, _strictTicks).push(now);
+    } else {
+        _classPrivateFieldUpdate(this, _intervalCount).value++;
+    }
+}
+function rollbackIntervalSlot() {
+    if (_classPrivateFieldGet(this, _strict)) {
+        // Pop from the end of the actual data (not from start index)
+        if (_classPrivateFieldGet(this, _strictTicks).length > _classPrivateFieldGet(this, _strictTicksStartIndex)) {
+            _classPrivateFieldGet(this, _strictTicks).pop();
+        }
+    } else if (_classPrivateFieldGet(this, _intervalCount) > 0) {
+        _classPrivateFieldUpdate(this, _intervalCount).value--;
+    }
+}
+function getActiveTicksCount() {
+    return _classPrivateFieldGet(this, _strictTicks).length - _classPrivateFieldGet(this, _strictTicksStartIndex);
+}
 function get_doesIntervalAllowAnother() {
-    return _classPrivateFieldGet(this, _isIntervalIgnored) || _classPrivateFieldGet(this, _intervalCount) < _classPrivateFieldGet(this, _intervalCap);
+    if (_classPrivateFieldGet(this, _isIntervalIgnored)) {
+        return true;
+    }
+    if (_classPrivateFieldGet(this, _strict)) {
+        // Cleanup already done by #isIntervalPausedAt before this is called
+        return _classPrivateMethodGet(this, _getActiveTicksCount, getActiveTicksCount).call(this) < _classPrivateFieldGet(this, _intervalCap);
+    }
+    return _classPrivateFieldGet(this, _intervalCount) < _classPrivateFieldGet(this, _intervalCap);
 }
 function get_doesConcurrentAllowAnother() {
     return _classPrivateFieldGet(this, _pending) < _classPrivateFieldGet(this, _concurrency);
 }
 function next() {
     _classPrivateFieldUpdate(this, _pending).value--;
+    if (_classPrivateFieldGet(this, _pending) === 0) {
+        this.emit("pendingZero");
+    }
     _classPrivateMethodGet(this, _tryToStartAnother, tryToStartAnother).call(this);
     this.emit("next");
 }
 function onResumeInterval() {
+    _classPrivateFieldSet(this, _timeoutId, undefined);
     _classPrivateMethodGet(this, _onInterval, onInterval).call(this);
     _classPrivateMethodGet(this, _initializeIntervalIfNeeded, initializeIntervalIfNeeded).call(this);
-    _classPrivateFieldSet(this, _timeoutId, undefined);
 }
-function get_isIntervalPaused() {
-    var _this = this;
-    var now = Date.now();
+function isIntervalPausedAt(now) {
+    // Strict mode: check if we need to wait for oldest tick to age out
+    if (_classPrivateFieldGet(this, _strict)) {
+        _classPrivateMethodGet(this, _cleanupStrictTicks, cleanupStrictTicks).call(this, now);
+        // If at capacity, need to wait for oldest tick to age out
+        var activeTicksCount = _classPrivateMethodGet(this, _getActiveTicksCount, getActiveTicksCount).call(this);
+        if (activeTicksCount >= _classPrivateFieldGet(this, _intervalCap)) {
+            var oldestTick = _classPrivateFieldGet(this, _strictTicks)[_classPrivateFieldGet(this, _strictTicksStartIndex)];
+            // After cleanup, remaining ticks are within interval, so delay is always > 0
+            var delay = _classPrivateFieldGet(this, _interval) - (now - oldestTick);
+            _classPrivateMethodGet(this, _createIntervalTimeout, createIntervalTimeout).call(this, delay);
+            return true;
+        }
+        return false;
+    }
+    // Fixed window mode (original logic)
     if (_classPrivateFieldGet(this, _intervalId) === undefined) {
-        var delay = _classPrivateFieldGet(this, _intervalEnd) - now;
-        if (delay < 0) {
-            _classPrivateFieldSet(this, _intervalCount, _classPrivateFieldGet(this, _carryoverConcurrencyCount) ? _classPrivateFieldGet(this, _pending) : 0);
+        var delay1 = _classPrivateFieldGet(this, _intervalEnd) - now;
+        if (delay1 < 0) {
+            // If the interval has expired while idle, check if we should enforce the interval
+            // from the last task execution. This ensures proper spacing between tasks even
+            // when the queue becomes empty and then new tasks are added.
+            if (_classPrivateFieldGet(this, _lastExecutionTime) > 0) {
+                var timeSinceLastExecution = now - _classPrivateFieldGet(this, _lastExecutionTime);
+                if (timeSinceLastExecution < _classPrivateFieldGet(this, _interval)) {
+                    // Not enough time has passed since the last task execution
+                    _classPrivateMethodGet(this, _createIntervalTimeout, createIntervalTimeout).call(this, _classPrivateFieldGet(this, _interval) - timeSinceLastExecution);
+                    return true;
+                }
+            }
+            _classPrivateFieldSet(this, _intervalCount, _classPrivateFieldGet(this, _carryoverIntervalCount) ? _classPrivateFieldGet(this, _pending) : 0);
         } else {
             // Act as the interval is pending
-            if (_classPrivateFieldGet(this, _timeoutId) === undefined) {
-                _classPrivateFieldSet(this, _timeoutId, setTimeout(function() {
-                    _classPrivateMethodGet(_this, _onResumeInterval, onResumeInterval).call(_this);
-                }, delay));
-            }
+            _classPrivateMethodGet(this, _createIntervalTimeout, createIntervalTimeout).call(this, delay1);
             return true;
         }
     }
     return false;
 }
+function createIntervalTimeout(delay) {
+    var _this = this;
+    if (_classPrivateFieldGet(this, _timeoutId) !== undefined) {
+        return;
+    }
+    _classPrivateFieldSet(this, _timeoutId, setTimeout(function() {
+        _classPrivateMethodGet(_this, _onResumeInterval, onResumeInterval).call(_this);
+    }, delay));
+}
+function clearIntervalTimer() {
+    if (_classPrivateFieldGet(this, _intervalId)) {
+        clearInterval(_classPrivateFieldGet(this, _intervalId));
+        _classPrivateFieldSet(this, _intervalId, undefined);
+    }
+}
+function clearTimeoutTimer() {
+    if (_classPrivateFieldGet(this, _timeoutId)) {
+        clearTimeout(_classPrivateFieldGet(this, _timeoutId));
+        _classPrivateFieldSet(this, _timeoutId, undefined);
+    }
+}
 function tryToStartAnother() {
     if (_classPrivateFieldGet(this, _queue).size === 0) {
         // We can clear the interval ("pause")
         // Because we can redo it later ("resume")
-        if (_classPrivateFieldGet(this, _intervalId)) {
-            clearInterval(_classPrivateFieldGet(this, _intervalId));
-        }
-        _classPrivateFieldSet(this, _intervalId, undefined);
+        _classPrivateMethodGet(this, _clearIntervalTimer, clearIntervalTimer).call(this);
         this.emit("empty");
         if (_classPrivateFieldGet(this, _pending) === 0) {
+            // Clear timeout as well when completely idle
+            _classPrivateMethodGet(this, _clearTimeoutTimer, clearTimeoutTimer).call(this);
+            // Compact strict ticks when idle to free memory
+            if (_classPrivateFieldGet(this, _strict) && _classPrivateFieldGet(this, _strictTicksStartIndex) > 0) {
+                var now = Date.now();
+                _classPrivateMethodGet(this, _cleanupStrictTicks, cleanupStrictTicks).call(this, now);
+            }
             this.emit("idle");
         }
         return false;
     }
+    var taskStarted = false;
     if (!_classPrivateFieldGet(this, _isPaused)) {
-        var canInitializeInterval = !_classPrivateFieldGet(this, _isIntervalPaused);
+        var now1 = Date.now();
+        var canInitializeInterval = !_classPrivateMethodGet(this, _isIntervalPausedAt, isIntervalPausedAt).call(this, now1);
         if (_classPrivateFieldGet(this, _doesIntervalAllowAnother) && _classPrivateFieldGet(this, _doesConcurrentAllowAnother)) {
             var job = _classPrivateFieldGet(this, _queue).dequeue();
-            if (!job) {
-                return false;
+            if (!_classPrivateFieldGet(this, _isIntervalIgnored)) {
+                _classPrivateMethodGet(this, _consumeIntervalSlot, consumeIntervalSlot).call(this, now1);
+                _classPrivateMethodGet(this, _scheduleRateLimitUpdate, scheduleRateLimitUpdate).call(this);
             }
             this.emit("active");
             job();
             if (canInitializeInterval) {
                 _classPrivateMethodGet(this, _initializeIntervalIfNeeded, initializeIntervalIfNeeded).call(this);
             }
-            return true;
+            taskStarted = true;
         }
     }
-    return false;
+    return taskStarted;
 }
 function initializeIntervalIfNeeded() {
     var _this = this;
     if (_classPrivateFieldGet(this, _isIntervalIgnored) || _classPrivateFieldGet(this, _intervalId) !== undefined) {
         return;
     }
+    // Strict mode uses timeouts instead of interval timers
+    if (_classPrivateFieldGet(this, _strict)) {
+        return;
+    }
     _classPrivateFieldSet(this, _intervalId, setInterval(function() {
         _classPrivateMethodGet(_this, _onInterval, onInterval).call(_this);
     }, _classPrivateFieldGet(this, _interval)));
     _classPrivateFieldSet(this, _intervalEnd, Date.now() + _classPrivateFieldGet(this, _interval));
 }
 function onInterval() {
-    if (_classPrivateFieldGet(this, _intervalCount) === 0 && _classPrivateFieldGet(this, _pending) === 0 && _classPrivateFieldGet(this, _intervalId)) {
-        clearInterval(_classPrivateFieldGet(this, _intervalId));
-        _classPrivateFieldSet(this, _intervalId, undefined);
+    // Non-strict mode uses interval timers and intervalCount
+    if (!_classPrivateFieldGet(this, _strict)) {
+        if (_classPrivateFieldGet(this, _intervalCount) === 0 && _classPrivateFieldGet(this, _pending) === 0 && _classPrivateFieldGet(this, _intervalId)) {
+            _classPrivateMethodGet(this, _clearIntervalTimer, clearIntervalTimer).call(this);
+        }
+        _classPrivateFieldSet(this, _intervalCount, _classPrivateFieldGet(this, _carryoverIntervalCount) ? _classPrivateFieldGet(this, _pending) : 0);
     }
-    _classPrivateFieldSet(this, _intervalCount, _classPrivateFieldGet(this, _carryoverConcurrencyCount) ? _classPrivateFieldGet(this, _pending) : 0);
     _classPrivateMethodGet(this, _processQueue, processQueue).call(this);
+    _classPrivateMethodGet(this, _scheduleRateLimitUpdate, scheduleRateLimitUpdate).call(this);
 }
 function processQueue() {
     // eslint-disable-next-line no-empty
     while(_classPrivateMethodGet(this, _tryToStartAnother, tryToStartAnother).call(this)){}
 }
-function throwOnAbort(signal) {
-    return _throwOnAbort1.apply(this, arguments);
-}
-function _throwOnAbort1() {
-    _throwOnAbort1 = _asyncToGenerator(function(signal) {
-        return __generator(this, function(_state) {
-            return [
-                2,
-                new Promise(function(_resolve, reject) {
-                    signal.addEventListener("abort", function() {
-                        reject(signal.reason);
-                    }, {
-                        once: true
-                    });
-                })
-            ];
-        });
-    });
-    return _throwOnAbort1.apply(this, arguments);
-}
-function onEvent(event, filter) {
+function onEvent(events, filter) {
     return _onEvent1.apply(this, arguments);
 }
 function _onEvent1() {
-    _onEvent1 = _asyncToGenerator(function(event, filter) {
-        var _this;
+    _onEvent1 = _asyncToGenerator(function(events, filter) {
+        var _this, eventList;
         return __generator(this, function(_state) {
             _this = this;
+            eventList = Array.isArray(events) ? events : [
+                events
+            ];
             return [
                 2,
                 new Promise(function(resolve) {
@@ -917,13 +1503,112 @@ function _onEvent1() {
                         if (filter && !filter()) {
                             return;
                         }
-                        _this.off(event, listener);
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = eventList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var event = _step.value;
+                                _this.off(event, listener);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
                         resolve();
                     };
-                    _this.on(event, listener);
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = eventList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var event = _step.value;
+                            _this.on(event, listener);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
                 })
             ];
         });
     });
     return _onEvent1.apply(this, arguments);
 }
+function setupRateLimitTracking() {
+    var _this = this;
+    // Only schedule updates when rate limiting is enabled
+    if (_classPrivateFieldGet(this, _isIntervalIgnored)) {
+        return;
+    }
+    // Wire up to lifecycle events that affect rate limit state
+    // Only 'add' and 'next' can actually change rate limit state
+    this.on("add", function() {
+        if (_classPrivateFieldGet(_this, _queue).size > 0) {
+            _classPrivateMethodGet(_this, _scheduleRateLimitUpdate, scheduleRateLimitUpdate).call(_this);
+        }
+    });
+    this.on("next", function() {
+        _classPrivateMethodGet(_this, _scheduleRateLimitUpdate, scheduleRateLimitUpdate).call(_this);
+    });
+}
+function scheduleRateLimitUpdate() {
+    var _this = this;
+    // Skip if rate limiting is not enabled or already scheduled
+    if (_classPrivateFieldGet(this, _isIntervalIgnored) || _classPrivateFieldGet(this, _rateLimitFlushScheduled)) {
+        return;
+    }
+    _classPrivateFieldSet(this, _rateLimitFlushScheduled, true);
+    queueMicrotask(function() {
+        _classPrivateFieldSet(_this, _rateLimitFlushScheduled, false);
+        _classPrivateMethodGet(_this, _updateRateLimitState, updateRateLimitState).call(_this);
+    });
+}
+function rollbackIntervalConsumption() {
+    if (_classPrivateFieldGet(this, _isIntervalIgnored)) {
+        return;
+    }
+    _classPrivateMethodGet(this, _rollbackIntervalSlot, rollbackIntervalSlot).call(this);
+    _classPrivateMethodGet(this, _scheduleRateLimitUpdate, scheduleRateLimitUpdate).call(this);
+}
+function updateRateLimitState() {
+    var previous = _classPrivateFieldGet(this, _rateLimitedInInterval);
+    // Early exit if rate limiting is disabled or queue is empty
+    if (_classPrivateFieldGet(this, _isIntervalIgnored) || _classPrivateFieldGet(this, _queue).size === 0) {
+        if (previous) {
+            _classPrivateFieldSet(this, _rateLimitedInInterval, false);
+            this.emit("rateLimitCleared");
+        }
+        return;
+    }
+    // Get the current count based on mode
+    var count;
+    if (_classPrivateFieldGet(this, _strict)) {
+        var now = Date.now();
+        _classPrivateMethodGet(this, _cleanupStrictTicks, cleanupStrictTicks).call(this, now);
+        count = _classPrivateMethodGet(this, _getActiveTicksCount, getActiveTicksCount).call(this);
+    } else {
+        count = _classPrivateFieldGet(this, _intervalCount);
+    }
+    var shouldBeRateLimited = count >= _classPrivateFieldGet(this, _intervalCap);
+    if (shouldBeRateLimited !== previous) {
+        _classPrivateFieldSet(this, _rateLimitedInInterval, shouldBeRateLimited);
+        this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+}