Upgrade Ava to v4

node_modules/p-limit/index.js

@@ -1,52 +1,68 @@
-'use strict';
-const pTry = require('p-try');
+import Queue from 'yocto-queue';
 
-const pLimit = concurrency => {
-	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
-		return Promise.reject(new TypeError('Expected `concurrency` to be a number from 1 and up'));
+export default function pLimit(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
 	}
 
-	const queue = [];
+	const queue = new Queue();
 	let activeCount = 0;
 
 	const next = () => {
 		activeCount--;
 
-		if (queue.length > 0) {
-			queue.shift()();
+		if (queue.size > 0) {
+			queue.dequeue()();
 		}
 	};
 
-	const run = (fn, resolve, ...args) => {
+	const run = async (fn, resolve, args) => {
 		activeCount++;
 
-		const result = pTry(fn, ...args);
+		const result = (async () => fn(...args))();
 
 		resolve(result);
 
-		result.then(next, next);
+		try {
+			await result;
+		} catch {}
+
+		next();
 	};
 
-	const enqueue = (fn, resolve, ...args) => {
-		if (activeCount < concurrency) {
-			run(fn, resolve, ...args);
-		} else {
-			queue.push(run.bind(null, fn, resolve, ...args));
-		}
+	const enqueue = (fn, resolve, args) => {
+		queue.enqueue(run.bind(undefined, fn, resolve, args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
 	};
 
-	const generator = (fn, ...args) => new Promise(resolve => enqueue(fn, resolve, ...args));
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, args);
+	});
+
 	Object.defineProperties(generator, {
 		activeCount: {
-			get: () => activeCount
+			get: () => activeCount,
 		},
 		pendingCount: {
-			get: () => queue.length
-		}
+			get: () => queue.size,
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			},
+		},
 	});
 
 	return generator;
-};
-
-module.exports = pLimit;
-module.exports.default = pLimit;
+}