Fix concurrency control in pMapIterable

Fixes sindresorhus#76

index.js

@@ -191,31 +191,31 @@ export function pMapIterable(
 			const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
 
 			const promises = [];
-			let runningMappersCount = 0;
+			let pendingPromisesCount = 0;
 			let isDone = false;
 			let index = 0;
 
 			function trySpawn() {
-				if (isDone || !(runningMappersCount < concurrency && promises.length < backpressure)) {
+				if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) {
 					return;
 				}
 
 				const promise = (async () => {
+					pendingPromisesCount++;
 					const {done, value} = await iterator.next();
 
 					if (done) {
+						pendingPromisesCount--;
 						return {done: true};
 					}
 
-					runningMappersCount++;
-
 					// Spawn if still below concurrency and backpressure limit
 					trySpawn();
 
 					try {
 						const returnValue = await mapper(await value, index++);
 
-						runningMappersCount--;
+						pendingPromisesCount--;
 
 						if (returnValue === pMapSkip) {
 							const index = promises.indexOf(promise);

test.js

@@ -637,6 +637,23 @@ test('pMapIterable - backpressure', async t => {
 	t.is(currentValue, 40);
 });
 
+test('pMapIterable - async input, backpressure > concurrency', async t => {
+	async function * source() {
+		yield 1;
+		yield 2;
+		yield 3;
+	}
+
+	const log = [];
+	await collectAsyncIterable(pMapIterable(source(), async n => {
+		log.push(n);
+		await delay(100);
+		log.push(n);
+	}, {concurrency: 1, backpressure: 2}));
+
+	t.deepEqual(log, [1, 1, 2, 2, 3, 3]);
+});
+
 test('pMapIterable - pMapSkip', async t => {
 	t.deepEqual(await collectAsyncIterable(pMapIterable([
 		1,