@depup/p-queue 9.1.1-depup.0

package/dist/lower-bound.d.ts

@@ -0,0 +1 @@
+export default function lowerBound<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;

package/dist/lower-bound.js

@@ -0,0 +1,18 @@
+// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound
+// Used to compute insertion index to keep queue sorted after insertion
+export default function lowerBound(array, value, comparator) {
+    let first = 0;
+    let count = array.length;
+    while (count > 0) {
+        const step = Math.trunc(count / 2);
+        let it = first + step;
+        if (comparator(array[it], value) <= 0) {
+            first = ++it;
+            count -= step + 1;
+        }
+        else {
+            count = step;
+        }
+    }
+    return first;
+}

package/dist/options.d.ts

@@ -0,0 +1,137 @@
+import { type Queue, type RunFunction } from './queue.js';
+type TimeoutOptions = {
+    /**
+    Per-operation timeout in milliseconds. 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.
+
+    @default undefined
+
+    Can be overridden per task using the `timeout` option in `.add()`:
+
+    @example
+    ```
+    const queue = new PQueue({timeout: 5000});
+
+    // This task uses the global 5s timeout
+    await queue.add(() => fetchData());
+
+    // This task has a 10s timeout
+    await queue.add(() => slowTask(), {timeout: 10000});
+    ```
+    */
+    timeout?: number;
+};
+export type Options<QueueType extends Queue<RunFunction, QueueOptions>, QueueOptions extends QueueAddOptions> = {
+    /**
+    Concurrency limit.
+
+    Minimum: `1`.
+
+    @default Infinity
+    */
+    readonly concurrency?: number;
+    /**
+    Whether queue tasks within concurrency limit, are auto-executed as soon as they're added.
+
+    @default true
+    */
+    readonly autoStart?: boolean;
+    /**
+    Class with a `enqueue` and `dequeue` method, and a `size` getter. See the [Custom QueueClass](https://github.com/sindresorhus/p-queue#custom-queueclass) section.
+    */
+    readonly queueClass?: new () => QueueType;
+    /**
+    The max number of runs in the given interval of time.
+
+    Minimum: `1`.
+
+    @default Infinity
+    */
+    readonly intervalCap?: number;
+    /**
+    The length of time in milliseconds before the interval count resets. Must be finite.
+
+    Minimum: `0`.
+
+    @default 0
+    */
+    readonly interval?: number;
+    /**
+    Whether the task must finish in the given interval or will be carried over into the next interval count.
+
+    @default false
+    */
+    readonly carryoverIntervalCount?: boolean;
+    /**
+    @deprecated Renamed to `carryoverIntervalCount`.
+    */
+    readonly carryoverConcurrencyCount?: boolean;
+    /**
+    Whether to use strict mode for rate limiting (sliding window algorithm).
+
+    When enabled, ensures that no more than `intervalCap` tasks execute in any rolling `interval` window, rather than resetting the count at fixed intervals. This provides more predictable and evenly distributed execution.
+
+    @default false
+
+    For example, with `intervalCap: 2` and `interval: 1000`:
+    - __Default mode (fixed window)__: Tasks can burst at window boundaries. You could execute 2 tasks at 999ms and 2 more at 1000ms, resulting in 4 tasks within 1ms.
+    - __Strict mode (sliding window)__: Enforces that no more than 2 tasks execute in any 1000ms rolling window, preventing bursts.
+
+    Strict mode is more resource-intensive as it tracks individual execution timestamps. Use it when you need guaranteed rate-limit compliance, such as when interacting with APIs that enforce strict rate limits.
+
+    The `carryoverIntervalCount` option has no effect when `strict` mode is enabled, as strict mode tracks actual execution timestamps rather than counting pending tasks.
+    */
+    readonly strict?: boolean;
+} & TimeoutOptions;
+export type QueueAddOptions = {
+    /**
+    Priority of operation. Operations with greater priority will be scheduled first.
+
+    @default 0
+    */
+    readonly priority?: number;
+    /**
+    Unique identifier for the promise function, used to update its priority before execution. If not specified, it is auto-assigned an incrementing BigInt starting from `1n`.
+    */
+    id?: string;
+} & TaskOptions & TimeoutOptions;
+export type TaskOptions = {
+    /**
+    [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) for cancellation of the operation. When aborted, it will be removed from the queue and the `queue.add()` call will reject with an `AbortError`. If the operation is already running, the signal will need to be handled by the operation itself.
+
+    @example
+    ```
+    import PQueue, {AbortError} from 'p-queue';
+    import got, {CancelError} from 'got';
+
+    const queue = new PQueue();
+
+    const controller = new AbortController();
+
+    try {
+        await queue.add(({signal}) => {
+            const request = got('https://sindresorhus.com');
+
+            signal.addEventListener('abort', () => {
+                request.cancel();
+            });
+
+            try {
+                return await request;
+            } catch (error) {
+                if (!(error instanceof CancelError)) {
+                    throw error;
+                }
+            }
+        }, {signal: controller.signal});
+    } catch (error) {
+        if (!(error instanceof AbortError)) {
+            throw error;
+        }
+    }
+    ```
+    */
+    readonly signal?: AbortSignal | undefined;
+};
+export {};

package/dist/options.js

@@ -0,0 +1 @@
+export {};

package/dist/priority-queue.d.ts

@@ -0,0 +1,15 @@
+import { type Queue, type RunFunction } from './queue.js';
+import { type QueueAddOptions } from './options.js';
+export type PriorityQueueOptions = {
+    priority?: number;
+} & QueueAddOptions;
+export default class PriorityQueue implements Queue<RunFunction, PriorityQueueOptions> {
+    #private;
+    enqueue(run: RunFunction, options?: Partial<PriorityQueueOptions>): void;
+    setPriority(id: string, priority: number): void;
+    remove(id: string): void;
+    remove(run: RunFunction): void;
+    dequeue(): RunFunction | undefined;
+    filter(options: Readonly<Partial<PriorityQueueOptions>>): RunFunction[];
+    get size(): number;
+}

package/dist/priority-queue.js

@@ -0,0 +1,47 @@
+import lowerBound from './lower-bound.js';
+export default class PriorityQueue {
+    #queue = [];
+    enqueue(run, options) {
+        const { priority = 0, id, } = options ?? {};
+        const element = {
+            priority,
+            id,
+            run,
+        };
+        if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
+            this.#queue.push(element);
+            return;
+        }
+        const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+        this.#queue.splice(index, 0, element);
+    }
+    setPriority(id, priority) {
+        const index = this.#queue.findIndex((element) => element.id === id);
+        if (index === -1) {
+            throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+        }
+        const [item] = this.#queue.splice(index, 1);
+        this.enqueue(item.run, { priority, id });
+    }
+    remove(idOrRun) {
+        const index = this.#queue.findIndex((element) => {
+            if (typeof idOrRun === 'string') {
+                return element.id === idOrRun;
+            }
+            return element.run === idOrRun;
+        });
+        if (index !== -1) {
+            this.#queue.splice(index, 1);
+        }
+    }
+    dequeue() {
+        const item = this.#queue.shift();
+        return item?.run;
+    }
+    filter(options) {
+        return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+    }
+    get size() {
+        return this.#queue.length;
+    }
+}

package/dist/queue.d.ts

@@ -0,0 +1,9 @@
+export type RunFunction = () => Promise<unknown>;
+export type Queue<Element, Options> = {
+    size: number;
+    filter: (options: Readonly<Partial<Options>>) => Element[];
+    dequeue: () => Element | undefined;
+    enqueue: (run: Element, options?: Partial<Options>) => void;
+    setPriority: (id: string, priority: number) => void;
+    remove?: (id: string) => void;
+};

package/dist/queue.js

@@ -0,0 +1 @@
+export {};

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@depup/p-queue",
+  "version": "9.1.1-depup.0",
+  "description": "Promise queue with concurrency control (with updated dependencies)",
+  "license": "MIT",
+  "repository": "sindresorhus/p-queue",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "type": "module",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "del-cli dist && tsc",
+    "test": "xo && node --import=tsx/esm --test test/*.ts && del-cli dist && tsc && tsd",
+    "bench": "node --import=tsx/esm bench.ts"
+  },
+  "files": [
+    "dist",
+    "changes.json",
+    "README.md"
+  ],
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "p-queue",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "promise",
+    "queue",
+    "enqueue",
+    "limit",
+    "limited",
+    "concurrency",
+    "throttle",
+    "throat",
+    "rate",
+    "batch",
+    "ratelimit",
+    "priority",
+    "priorityqueue",
+    "fifo",
+    "job",
+    "task",
+    "async",
+    "await",
+    "promises",
+    "bluebird"
+  ],
+  "dependencies": {
+    "eventemitter3": "^5.0.4",
+    "p-timeout": "^7.0.1"
+  },
+  "devDependencies": {
+    "@sindresorhus/tsconfig": "^8.0.1",
+    "@types/benchmark": "^2.1.5",
+    "@types/node": "^24.5.1",
+    "benchmark": "^2.1.4",
+    "del-cli": "^6.0.0",
+    "delay": "^6.0.0",
+    "in-range": "^3.0.0",
+    "p-defer": "^4.0.1",
+    "random-int": "^3.1.0",
+    "time-span": "^5.1.0",
+    "tsd": "^0.33.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "xo": "^1.2.2"
+  },
+  "xo": {
+    "rules": {
+      "@typescript-eslint/member-ordering": "off",
+      "@typescript-eslint/no-floating-promises": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "@typescript-eslint/no-unsafe-argument": "off",
+      "@typescript-eslint/prefer-promise-reject-errors": "off",
+      "ava/no-import-test-files": "off"
+    }
+  },
+  "depup": {
+    "changes": {
+      "eventemitter3": {
+        "from": "^5.0.1",
+        "to": "^5.0.4"
+      },
+      "p-timeout": {
+        "from": "^7.0.0",
+        "to": "^7.0.1"
+      }
+    },
+    "depsUpdated": 2,
+    "originalPackage": "p-queue",
+    "originalVersion": "9.1.1",
+    "processedAt": "2026-04-01T20:19:42.008Z",
+    "smokeTest": "passed"
+  }
+}