@common.js/p-queue 7.3.0

package/dist/index.js

@@ -0,0 +1,850 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return PQueue;
+    },
+    AbortError: function() {
+        return AbortError;
+    }
+});
+var _eventemitter3 = /*#__PURE__*/ _interopRequireDefault(require("eventemitter3"));
+var _pTimeout = /*#__PURE__*/ _interopRequireWildcard(require("p-timeout"));
+var _priorityQueueJs = /*#__PURE__*/ _interopRequireDefault(require("./priority-queue.js"));
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var __classPrivateFieldSet = (void 0) && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = (void 0) && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PQueue_instances, _PQueue_carryoverConcurrencyCount, _PQueue_isIntervalIgnored, _PQueue_intervalCount, _PQueue_intervalCap, _PQueue_interval, _PQueue_intervalEnd, _PQueue_intervalId, _PQueue_timeoutId, _PQueue_queue, _PQueue_queueClass, _PQueue_pendingCount, _PQueue_concurrency, _PQueue_isPaused, _PQueue_throwOnTimeout, _PQueue_doesIntervalAllowAnother_get, _PQueue_doesConcurrentAllowAnother_get, _PQueue_next, _PQueue_emitEvents, _PQueue_onResumeInterval, _PQueue_isIntervalPaused_get, _PQueue_tryToStartAnother, _PQueue_initializeIntervalIfNeeded, _PQueue_onInterval, _PQueue_processQueue, _PQueue_onEvent;
+var timeoutError = new _pTimeout.TimeoutError();
+var AbortError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(AbortError, Error1);
+    var _super = _createSuper(AbortError);
+    function AbortError() {
+        _classCallCheck(this, AbortError);
+        return _super.apply(this, arguments);
+    }
+    return AbortError;
+}(_wrapNativeSuper(Error));
+var PQueue = /*#__PURE__*/ function(EventEmitter) {
+    "use strict";
+    _inherits(PQueue, EventEmitter);
+    var _super = _createSuper(PQueue);
+    function PQueue(options) {
+        _classCallCheck(this, PQueue);
+        var _this;
+        var _a, _b, _c, _d;
+        _this = _super.call(this);
+        _PQueue_instances.add(_assertThisInitialized(_this));
+        _PQueue_carryoverConcurrencyCount.set(_assertThisInitialized(_this), void 0);
+        _PQueue_isIntervalIgnored.set(_assertThisInitialized(_this), void 0);
+        _PQueue_intervalCount.set(_assertThisInitialized(_this), 0);
+        _PQueue_intervalCap.set(_assertThisInitialized(_this), void 0);
+        _PQueue_interval.set(_assertThisInitialized(_this), void 0);
+        _PQueue_intervalEnd.set(_assertThisInitialized(_this), 0);
+        _PQueue_intervalId.set(_assertThisInitialized(_this), void 0);
+        _PQueue_timeoutId.set(_assertThisInitialized(_this), void 0);
+        _PQueue_queue.set(_assertThisInitialized(_this), void 0);
+        _PQueue_queueClass.set(_assertThisInitialized(_this), void 0);
+        _PQueue_pendingCount.set(_assertThisInitialized(_this), 0);
+        // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+        _PQueue_concurrency.set(_assertThisInitialized(_this), void 0);
+        _PQueue_isPaused.set(_assertThisInitialized(_this), void 0);
+        _PQueue_throwOnTimeout.set(_assertThisInitialized(_this), void 0);
+        /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    
+        Applies to each future operation.
+        */ Object.defineProperty(_assertThisInitialized(_this), "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        options = _objectSpread({
+            carryoverConcurrencyCount: false,
+            intervalCap: Number.POSITIVE_INFINITY,
+            interval: 0,
+            concurrency: Number.POSITIVE_INFINITY,
+            autoStart: true,
+            queueClass: _priorityQueueJs.default
+        }, options);
+        if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+            throw new TypeError("Expected `intervalCap` to be a number from 1 and up, got `".concat((_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "", "` (").concat(_typeof(options.intervalCap), ")"));
+        }
+        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+            throw new TypeError("Expected `interval` to be a finite number >= 0, got `".concat((_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : "", "` (").concat(_typeof(options.interval), ")"));
+        }
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_carryoverConcurrencyCount, options.carryoverConcurrencyCount, "f");
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0, "f");
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_intervalCap, options.intervalCap, "f");
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_interval, options.interval, "f");
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_queue, new options.queueClass(), "f");
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_queueClass, options.queueClass, "f");
+        _this.concurrency = options.concurrency;
+        _this.timeout = options.timeout;
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_throwOnTimeout, options.throwOnTimeout === true, "f");
+        __classPrivateFieldSet(_assertThisInitialized(_this), _PQueue_isPaused, options.autoStart === false, "f");
+        return _this;
+    }
+    _createClass(PQueue, [
+        {
+            key: "concurrency",
+            get: function get() {
+                return __classPrivateFieldGet(this, _PQueue_concurrency, "f");
+            },
+            set: function set(newConcurrency) {
+                if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+                    throw new TypeError("Expected `concurrency` to be a number from 1 and up, got `".concat(newConcurrency, "` (").concat(typeof newConcurrency === "undefined" ? "undefined" : _typeof(newConcurrency), ")"));
+                }
+                __classPrivateFieldSet(this, _PQueue_concurrency, newConcurrency, "f");
+                __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+            }
+        },
+        {
+            key: "add",
+            value: /**
+    Adds a sync or async task to the queue. Always returns a promise.
+    */ function add(fn) {
+                var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        return [
+                            2,
+                            new Promise(function(resolve, reject) {
+                                var run = function() {
+                                    var _ref = _asyncToGenerator(function() {
+                                        var _a, _b, _c, operation, result, error;
+                                        return __generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    __classPrivateFieldSet(_this, _PQueue_pendingCount, (_b = __classPrivateFieldGet(_this, _PQueue_pendingCount, "f"), _b++, _b), "f");
+                                                    __classPrivateFieldSet(_this, _PQueue_intervalCount, (_c = __classPrivateFieldGet(_this, _PQueue_intervalCount, "f"), _c++, _c), "f");
+                                                    _state.label = 1;
+                                                case 1:
+                                                    _state.trys.push([
+                                                        1,
+                                                        3,
+                                                        ,
+                                                        4
+                                                    ]);
+                                                    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                                                        // TODO: Use ABORT_ERR code when targeting Node.js 16 (https://nodejs.org/docs/latest-v16.x/api/errors.html#abort_err)
+                                                        reject(new AbortError("The task was aborted."));
+                                                        return [
+                                                            2
+                                                        ];
+                                                    }
+                                                    operation = _this.timeout === undefined && options.timeout === undefined ? fn({
+                                                        signal: options.signal
+                                                    }) : (0, _pTimeout.default)(Promise.resolve(fn({
+                                                        signal: options.signal
+                                                    })), options.timeout === undefined ? _this.timeout : options.timeout, function() {
+                                                        if (options.throwOnTimeout === undefined ? __classPrivateFieldGet(_this, _PQueue_throwOnTimeout, "f") : options.throwOnTimeout) {
+                                                            reject(timeoutError);
+                                                        }
+                                                        return undefined;
+                                                    });
+                                                    return [
+                                                        4,
+                                                        operation
+                                                    ];
+                                                case 2:
+                                                    result = _state.sent();
+                                                    resolve(result);
+                                                    _this.emit("completed", result);
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                case 3:
+                                                    error = _state.sent();
+                                                    reject(error);
+                                                    _this.emit("error", error);
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                case 4:
+                                                    __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_next).call(_this);
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    });
+                                    return function run() {
+                                        return _ref.apply(this, arguments);
+                                    };
+                                }();
+                                __classPrivateFieldGet(_this, _PQueue_queue, "f").enqueue(run, options);
+                                __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(_this);
+                                _this.emit("add");
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "addAll",
+            value: /**
+    Same as `.add()`, but accepts an array of sync or async functions.
+
+    @returns A promise that resolves when all functions are resolved.
+    */ function addAll(functions, options) {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        return [
+                            2,
+                            Promise.all(functions.map(function() {
+                                var _ref = _asyncToGenerator(function(function_) {
+                                    return __generator(this, function(_state) {
+                                        return [
+                                            2,
+                                            _this.add(function_, options)
+                                        ];
+                                    });
+                                });
+                                return function(function_) {
+                                    return _ref.apply(this, arguments);
+                                };
+                            }()))
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            /**
+    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+    */ key: "start",
+            value: function start() {
+                if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
+                    return this;
+                }
+                __classPrivateFieldSet(this, _PQueue_isPaused, false, "f");
+                __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+                return this;
+            }
+        },
+        {
+            /**
+    Put queue execution on hold.
+    */ key: "pause",
+            value: function pause() {
+                __classPrivateFieldSet(this, _PQueue_isPaused, true, "f");
+            }
+        },
+        {
+            /**
+    Clear the queue.
+    */ key: "clear",
+            value: function clear() {
+                __classPrivateFieldSet(this, _PQueue_queue, new (__classPrivateFieldGet(this, _PQueue_queueClass, "f"))(), "f");
+            }
+        },
+        {
+            key: "onEmpty",
+            value: /**
+    Can be called multiple times. Useful if you for example add additional items at a later time.
+
+    @returns A promise that settles when the queue becomes empty.
+    */ function onEmpty() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Instantly resolve if the queue is empty
+                                if (__classPrivateFieldGet(_this, _PQueue_queue, "f").size === 0) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_onEvent).call(_this, "empty")
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "onSizeLessThan",
+            value: /**
+    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+
+    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+
+    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+    */ function onSizeLessThan(limit) {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Instantly resolve if the queue is empty.
+                                if (__classPrivateFieldGet(_this, _PQueue_queue, "f").size < limit) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_onEvent).call(_this, "next", function() {
+                                        return __classPrivateFieldGet(_this, _PQueue_queue, "f").size < limit;
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "onIdle",
+            value: /**
+    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+
+    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+    */ function onIdle() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Instantly resolve if none pending and if nothing else is queued
+                                if (__classPrivateFieldGet(_this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet(_this, _PQueue_queue, "f").size === 0) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_onEvent).call(_this, "idle")
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "size",
+            get: /**
+    Size of the queue, the number of queued items waiting to run.
+    */ function get() {
+                return __classPrivateFieldGet(this, _PQueue_queue, "f").size;
+            }
+        },
+        {
+            /**
+    Size of the queue, filtered by the given options.
+
+    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+    */ key: "sizeBy",
+            value: function sizeBy(options) {
+                // eslint-disable-next-line unicorn/no-array-callback-reference
+                return __classPrivateFieldGet(this, _PQueue_queue, "f").filter(options).length;
+            }
+        },
+        {
+            key: "pending",
+            get: /**
+    Number of running items (no longer in the queue).
+    */ function get() {
+                return __classPrivateFieldGet(this, _PQueue_pendingCount, "f");
+            }
+        },
+        {
+            key: "isPaused",
+            get: /**
+    Whether the queue is currently paused.
+    */ function get() {
+                return __classPrivateFieldGet(this, _PQueue_isPaused, "f");
+            }
+        }
+    ]);
+    return PQueue;
+}(_eventemitter3.default);
+_PQueue_carryoverConcurrencyCount = new WeakMap(), _PQueue_isIntervalIgnored = new WeakMap(), _PQueue_intervalCount = new WeakMap(), _PQueue_intervalCap = new WeakMap(), _PQueue_interval = new WeakMap(), _PQueue_intervalEnd = new WeakMap(), _PQueue_intervalId = new WeakMap(), _PQueue_timeoutId = new WeakMap(), _PQueue_queue = new WeakMap(), _PQueue_queueClass = new WeakMap(), _PQueue_pendingCount = new WeakMap(), _PQueue_concurrency = new WeakMap(), _PQueue_isPaused = new WeakMap(), _PQueue_throwOnTimeout = new WeakMap(), _PQueue_instances = new WeakSet(), _PQueue_doesIntervalAllowAnother_get = function _PQueue_doesIntervalAllowAnother_get() {
+    return __classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalCount, "f") < __classPrivateFieldGet(this, _PQueue_intervalCap, "f");
+}, _PQueue_doesConcurrentAllowAnother_get = function _PQueue_doesConcurrentAllowAnother_get() {
+    return __classPrivateFieldGet(this, _PQueue_pendingCount, "f") < __classPrivateFieldGet(this, _PQueue_concurrency, "f");
+}, _PQueue_next = function _PQueue_next() {
+    var _a;
+    __classPrivateFieldSet(this, _PQueue_pendingCount, (_a = __classPrivateFieldGet(this, _PQueue_pendingCount, "f"), _a--, _a), "f");
+    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
+    this.emit("next");
+}, _PQueue_emitEvents = function _PQueue_emitEvents() {
+    this.emit("empty");
+    if (__classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0) {
+        this.emit("idle");
+    }
+}, _PQueue_onResumeInterval = function _PQueue_onResumeInterval() {
+    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
+    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
+    __classPrivateFieldSet(this, _PQueue_timeoutId, undefined, "f");
+}, _PQueue_isIntervalPaused_get = function _PQueue_isIntervalPaused_get() {
+    var _this = this;
+    var now = Date.now();
+    if (__classPrivateFieldGet(this, _PQueue_intervalId, "f") === undefined) {
+        var delay = __classPrivateFieldGet(this, _PQueue_intervalEnd, "f") - now;
+        if (delay < 0) {
+            // Act as the interval was done
+            // We don't need to resume it here because it will be resumed on line 160
+            __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet(this, _PQueue_pendingCount, "f") : 0, "f");
+        } else {
+            // Act as the interval is pending
+            if (__classPrivateFieldGet(this, _PQueue_timeoutId, "f") === undefined) {
+                __classPrivateFieldSet(this, _PQueue_timeoutId, setTimeout(function() {
+                    __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_onResumeInterval).call(_this);
+                }, delay), "f");
+            }
+            return true;
+        }
+    }
+    return false;
+}, _PQueue_tryToStartAnother = function _PQueue_tryToStartAnother() {
+    if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
+        // We can clear the interval ("pause")
+        // Because we can redo it later ("resume")
+        if (__classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
+        }
+        __classPrivateFieldSet(this, _PQueue_intervalId, undefined, "f");
+        __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_emitEvents).call(this);
+        return false;
+    }
+    if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
+        var canInitializeInterval = !__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_isIntervalPaused_get);
+        if (__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesConcurrentAllowAnother_get)) {
+            var job = __classPrivateFieldGet(this, _PQueue_queue, "f").dequeue();
+            if (!job) {
+                return false;
+            }
+            this.emit("active");
+            job();
+            if (canInitializeInterval) {
+                __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
+            }
+            return true;
+        }
+    }
+    return false;
+}, _PQueue_initializeIntervalIfNeeded = function _PQueue_initializeIntervalIfNeeded() {
+    var _this = this;
+    if (__classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalId, "f") !== undefined) {
+        return;
+    }
+    __classPrivateFieldSet(this, _PQueue_intervalId, setInterval(function() {
+        __classPrivateFieldGet(_this, _PQueue_instances, "m", _PQueue_onInterval).call(_this);
+    }, __classPrivateFieldGet(this, _PQueue_interval, "f")), "f");
+    __classPrivateFieldSet(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet(this, _PQueue_interval, "f"), "f");
+}, _PQueue_onInterval = function _PQueue_onInterval() {
+    if (__classPrivateFieldGet(this, _PQueue_intervalCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
+        clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
+        __classPrivateFieldSet(this, _PQueue_intervalId, undefined, "f");
+    }
+    __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet(this, _PQueue_pendingCount, "f") : 0, "f");
+    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+}, _PQueue_processQueue = function _PQueue_processQueue() {
+    // eslint-disable-next-line no-empty
+    while(__classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this)){}
+}, _PQueue_onEvent = function() {
+    var __PQueue_onEvent = _asyncToGenerator(function(event, filter) {
+        var _this;
+        return __generator(this, function(_state) {
+            _this = this;
+            return [
+                2,
+                new Promise(function(resolve) {
+                    var listener = function() {
+                        if (filter && !filter()) {
+                            return;
+                        }
+                        _this.off(event, listener);
+                        resolve();
+                    };
+                    _this.on(event, listener);
+                })
+            ];
+        });
+    });
+    function _PQueue_onEvent(event, filter) {
+        return __PQueue_onEvent.apply(this, arguments);
+    }
+    return _PQueue_onEvent;
+}();