rubico's `map.pool` array implementation

Question

This is map.pool of my asynchronous function composition library, rubico.

You could use it like this; sleepThenDo is a toy function used for testing map.pool

const { map } = require('rubico')

const sleepThenDo = (ms, fn) => x => new Promise(resolve => {
  setTimeout(() => {
    fn(x)
    resolve()
  }, ms)
})

map.pool(2, sleepThenDo(1000, console.log))([1, 2, 3, 4, 5, 6]) /*
*waits a bit*
1
2 
*waits a bit*
3
4
*waits a bit*
5
6
*/

This is the implementation.

const mapPoolIndexedWorker = insert => (size, fn, resolve, reject, x, y, i) => {
  if (i >= x.length) return
  if (reject._called) return
  let point
  try {
    point = fn(x[i])
  } catch (err) {
    reject._called = true
    return reject(err)
  }
  if (isPromise(point)) {
    point.then(res => {
      insert(y, res, i)
      if (i === x.length - 1) {
        resolve(y)
      } else {
        mapPoolIndexedWorker(insert)(size, fn, resolve, reject, x, y, i + size)
      }
    }).catch(err => {
      reject._called = true
      reject(err)
    })
  } else {
    insert(y, point, i)
    if (i === x.length - 1) {
      resolve(y)
    } else {
      mapPoolIndexedWorker(insert)(size, fn, resolve, reject, x, y, i + size)
    }
  }
}

const mapPoolArrayWorker = mapPoolIndexedWorker((y, xi, i) => { y[i] = xi })

const mapPoolArray = (size, fn, x) => new Promise((resolve, reject) => {
  if (x.length < 1) return resolve([])
  const y = []
  for (let i = 0; i < Math.min(x.length, size); i++) {
    mapPoolArrayWorker(size, fn, resolve, reject, x, y, i, i) // start off the workers
  }
})

mapPoolArray is then called if the data argument is an array.

Is there the possibility of a memory leak here? It certainly works, but I want to know if it's okay memory-wise to think about a "pool" of workers this way. I would also like to know if there is any way to gaurantee a PACKED array on return