@@ -84,6 +84,8 @@ type WaitingTask = {
 	priority?: number;
 	promise?: Promise<unknown>;
 	reject?: (reason: unknown) => void;
+	// Stops listening for the abort of the `signal` of the task, when it starts or `.clear()` removes it.
+	stopListeningForAbort?: () => void;
 	isCleared?: boolean;
 };
 
@@ -145,7 +147,8 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 		timeout: number | undefined;
 	}>();
 
-	readonly #queueAbortListenerCleanupFunctions = new Set<() => void>();
+	// The `abort` listener of each signal, with the callbacks of the tasks that use the signal.
+	readonly #abortListeners = new Map<AbortSignal, {callbacks: Set<() => void>; dispatch: () => void}>();
 
 	// The waiting tasks, so that `.clear()` can reject their promises.
 	readonly #waitingTasks = new Set<WaitingTask>();
@@ -186,6 +189,41 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 		this.#setupRateLimitTracking();
 	}
 
+	// Calls `callback` when `signal` aborts, and returns a function that stops it. The tasks that share a signal share one listener on it, because Node.js searches all the listeners of a signal to add or remove one, so a listener for each task takes O(n²) time with many tasks.
+	#onAbort(signal: AbortSignal, callback: () => void): () => void {
+		let listener = this.#abortListeners.get(signal);
+		if (!listener) {
+			const callbacks = new Set<() => void>();
+			const dispatch = () => {
+				this.#abortListeners.delete(signal);
+
+				// Not a copy, so that a callback that an earlier callback removes is not called.
+				for (const abortCallback of callbacks) {
+					abortCallback();
+				}
+			};
+
+			listener = {callbacks, dispatch};
+			this.#abortListeners.set(signal, listener);
+			signal.addEventListener('abort', dispatch, {once: true});
+		}
+
+		const currentListener = listener;
+		currentListener.callbacks.add(callback);
+
+		return () => {
+			currentListener.callbacks.delete(callback);
+
+			// Not after the abort, when the listener is already gone, and a new one can be in the map.
+			if (currentListener.callbacks.size > 0 || this.#abortListeners.get(signal) !== currentListener) {
+				return;
+			}
+
+			this.#abortListeners.delete(signal);
+			signal.removeEventListener('abort', currentListener.dispatch);
+		};
+	}
+
 	#emit(event: EventName, detail?: unknown): void {
 		this.dispatchEvent(new CustomEvent(event, {detail}));
 	}
@@ -603,10 +641,9 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 			// Create a unique symbol for tracking this task
 			const taskSymbol = Symbol(`task-${id}`);
 
-			let cleanupQueueAbortHandler = () => undefined;
 			const run = bindAsyncContext(async () => {
 				// Task is now running, so remove the queued-state abort listener
-				cleanupQueueAbortHandler();
+				waitingTask.stopListeningForAbort?.();
 				this.#waitingTasks.delete(waitingTask);
 
 				// The signal aborted while the task waited, but its abort listener did not run yet, for example because another listener of the signal started the queue. Like an abort while waiting, the task does not start.
@@ -627,8 +664,8 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 				});
 
 				let {signal} = options;
-				let eventListener: (() => void) | undefined;
-				let forwardAbort: (() => void) | undefined;
+				let stopListeningForAbort: (() => void) | undefined;
+				let stopForwardingAbort: (() => void) | undefined;
 				let timeoutId: NodeJS.Timeout | undefined;
 
 				try {
@@ -641,11 +678,9 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 						}, timeout);
 
 						if (userSignal) {
-							forwardAbort = () => {
+							stopForwardingAbort = this.#onAbort(userSignal, () => {
 								taskController.abort(userSignal.reason);
-							};
-
-							userSignal.addEventListener('abort', forwardAbort, {once: true});
+							});
 						}
 
 						signal = taskController.signal;
@@ -658,11 +693,9 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 
 						// Listen before the task starts, so that an abort while the task starts is not missed, and so that the abort comes before the abort listeners of the task. The abort is first in the race, so it also wins when both are already settled.
 						const abortPromise = new Promise<never>((_resolve, rejectWithReason) => {
-							eventListener = () => {
+							stopListeningForAbort = this.#onAbort(abortSignal, () => {
 								rejectWithReason(abortSignal.reason);
-							};
-
-							abortSignal.addEventListener('abort', eventListener, {once: true});
+							});
 						});
 
 						// The `async` function turns a synchronous throw of the task into a rejection, so that `abortPromise` always has a handler.
@@ -688,13 +721,8 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 					clearTimeout(timeoutId);
 
 					// Clean up abort event listeners
-					if (eventListener) {
-						signal?.removeEventListener('abort', eventListener);
-					}
-
-					if (forwardAbort) {
-						options.signal?.removeEventListener('abort', forwardAbort);
-					}
+					stopListeningForAbort?.();
+					stopForwardingAbort?.();
 
 					// Remove from running tasks
 					this.#runningTasks.delete(taskSymbol);
@@ -711,36 +739,23 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 			waitingTask.reject = reject;
 			this.#waitingTasks.add(waitingTask);
 
-			const removeQueuedTask = () => {
-				if (this.#queue instanceof PriorityQueue) {
-					this.#queue.remove(run);
-					return;
-				}
-
-				this.#queue.remove(id);
-			};
-
 			// Handle abort while task is waiting in the queue
 			if (options.signal) {
 				const {signal} = options;
-
-				const queueAbortHandler = () => {
-					cleanupQueueAbortHandler();
+				waitingTask.stopListeningForAbort = this.#onAbort(signal, () => {
 					this.#waitingTasks.delete(waitingTask);
-					removeQueuedTask();
+
+					if (this.#queue instanceof PriorityQueue) {
+						this.#queue.remove(run);
+					} else {
+						this.#queue.remove(id);
+					}
+
 					reject(signal.reason);
 					// Not only one task: at the end of a window, the first start clears the resume timeout, which would start the others.
 					this.#processQueue();
 					this.#emit('next');
-				};
-
-				cleanupQueueAbortHandler = () => {
-					signal.removeEventListener('abort', queueAbortHandler);
-					this.#queueAbortListenerCleanupFunctions.delete(cleanupQueueAbortHandler);
-				};
-
-				signal.addEventListener('abort', queueAbortHandler, {once: true});
-				this.#queueAbortListenerCleanupFunctions.add(cleanupQueueAbortHandler);
+				});
 			}
 
 			this.#emit('add');
@@ -937,14 +952,11 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 			return;
 		}
 
-		for (const cleanupQueueAbortHandler of this.#queueAbortListenerCleanupFunctions) {
-			cleanupQueueAbortHandler();
-		}
-
 		this.#queue = new this.#queueClass();
 
 		const error = new DOMException('The queue was cleared', 'AbortError');
 		for (const waitingTask of this.#waitingTasks) {
+			waitingTask.stopListeningForAbort?.();
 			waitingTask.isCleared = true;
 			waitingTask.promise?.catch(() => undefined);
 			waitingTask.reject!(error);
 
@@ -25,6 +25,36 @@ export default class PriorityQueue implements Queue<RunFunction, PriorityQueueOp
 		this.#head = 0;
 	}
 
+	// Only the live items, because a dequeued item with the same id or function is no longer part of the queue.
+	#findIndex(isMatch: (element: PriorityQueueOptions & {run: RunFunction}) => boolean): number {
+		for (let index = this.#head; index < this.#queue.length; index++) {
+			if (isMatch(this.#queue[index]!)) {
+				return index;
+			}
+		}
+
+		return -1;
+	}
+
+	// Not `dequeue()`, which a subclass can override, because `remove()` also uses it.
+	#removeFirst(): RunFunction {
+		const item = this.#queue[this.#head]!;
+		// Drop the reference, so that the function of the task and what it holds can be garbage collected before compaction.
+		this.#queue[this.#head] = undefined;
+		this.#head++;
+
+		if (this.#head === this.#queue.length) {
+			// Fully drained queues are reset immediately so the next enqueue starts from a clean array.
+			this.#queue.length = 0;
+			this.#head = 0;
+		} else if (this.#head > compactionThreshold && this.#head > this.#queue.length / 2) {
+			// Keep repeated dequeues cheap, but stop the consumed prefix from growing without bound.
+			this.#compact();
+		}
+
+		return item.run;
+	}
+
 	enqueue(run: RunFunction, options?: Partial<PriorityQueueOptions>): void {
 		const {
 			priority = 0,
@@ -60,8 +90,7 @@ export default class PriorityQueue implements Queue<RunFunction, PriorityQueueOp
 	}
 
 	setPriority(id: string, priority: number) {
-		// A dequeued item with the same id is no longer part of the queue.
-		const index = this.#queue.findIndex((element, index) => index >= this.#head && element!.id === id);
+		const index = this.#findIndex(element => element.id === id);
 		if (index === -1) {
 			throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
 		}
@@ -78,34 +107,18 @@ export default class PriorityQueue implements Queue<RunFunction, PriorityQueueOp
 	remove(id: string): void;
 	remove(run: RunFunction): void;
 	remove(idOrRun: string | RunFunction): void {
-		// The consumed prefix has only `undefined` slots.
-		const index = this.#queue.findIndex((element, index) => index >= this.#head && (typeof idOrRun === 'string' ? element!.id : element!.run) === idOrRun);
+		const index = this.#findIndex(element => (typeof idOrRun === 'string' ? element.id : element.run) === idOrRun);
 
-		if (index !== -1) {
+		// Removing the first item is O(1). Aborting many tasks with one signal removes them in the order they were added, which is the queue order when they have the same priority, and a splice for each would be O(n²).
+		if (index === this.#head) {
+			this.#removeFirst();
+		} else if (index !== -1) {
 			this.#queue.splice(index, 1);
 		}
 	}
 
 	dequeue(): RunFunction | undefined {
-		if (this.#head === this.#queue.length) {
-			return undefined;
-		}
-
-		const item = this.#queue[this.#head]!;
-		// Drop the reference, so that the function of the task and what it holds can be garbage collected before compaction.
-		this.#queue[this.#head] = undefined;
-		this.#head++;
-
-		if (this.#head === this.#queue.length) {
-			// Fully drained queues are reset immediately so the next enqueue starts from a clean array.
-			this.#queue.length = 0;
-			this.#head = 0;
-		} else if (this.#head > compactionThreshold && this.#head > this.#queue.length / 2) {
-			// Keep repeated dequeues cheap, but stop the consumed prefix from growing without bound.
-			this.#compact();
-		}
-
-		return item.run;
+		return this.#head === this.#queue.length ? undefined : this.#removeFirst();
 	}
 
 	filter(options: Readonly<Partial<PriorityQueueOptions>>): RunFunction[] {