function map (coll, iteratee, callback) {
        return _asyncMap(eachOf$1, coll, iteratee, callback)
    }
Produces a new collection of values by mapping each value in `coll` through
the `iteratee` function. The `iteratee` is called with an item from `coll`
and a callback for when it has finished processing. Each of these callbacks
takes 2 arguments: an `error`, and the transformed item from `coll`. If
`iteratee` passes an error to its callback, the main `callback` (for the
`map` function) is immediately called with the error.

Note, that since this function applies the `iteratee` to each item in
parallel, there is no guarantee that the `iteratee` functions will complete
in order. However, the results array will be in the same order as the
original `coll`.

If `map` is passed an Object, the results will be an Array.  The results
will roughly be in the order of the original Objects' keys (but this can
vary across JavaScript engines).

@name map
@static
@memberOf module:Collections
@method
@category Collection
@param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
@param {AsyncFunction} iteratee - An async function to apply to each item in
`coll`.
The iteratee should complete with the transformed item.
Invoked with (item, callback).
@param {Function} [callback] - A callback which is called when all `iteratee`
functions have finished, or an error occurs. Results is an Array of the
transformed items from the `coll`. Invoked with (err, results).
@returns {Promise} a promise, if no callback is passed
@example

// file1.txt is a file that is 1000 bytes in size
// file2.txt is a file that is 2000 bytes in size
// file3.txt is a file that is 3000 bytes in size
// file4.txt does not exist

const fileList = ['file1.txt','file2.txt','file3.txt'];
const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];

// asynchronous function that returns the file size in bytes
function getFileSizeInBytes(file, callback) {
    fs.stat(file, function(err, stat) {
        if (err) {
            return callback(err);
        }
        callback(null, stat.size);
    });
}

// Using callbacks
async.map(fileList, getFileSizeInBytes, function(err, results) {
    if (err) {
        console.log(err);
    } else {
        console.log(results);
        // results is now an array of the file size in bytes for each file, e.g.
        // [ 1000, 2000, 3000]
    }
});

// Error Handling
async.map(withMissingFileList, getFileSizeInBytes, function(err, results) {
    if (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    } else {
        console.log(results);
    }
});

// Using Promises
async.map(fileList, getFileSizeInBytes)
.then( results => {
    console.log(results);
    // results is now an array of the file size in bytes for each file, e.g.
    // [ 1000, 2000, 3000]
}).catch( err => {
    console.log(err);
});

// Error Handling
async.map(withMissingFileList, getFileSizeInBytes)
.then( results => {
    console.log(results);
}).catch( err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
});

// Using async/await
async () => {
    try {
        let results = await async.map(fileList, getFileSizeInBytes);
        console.log(results);
        // results is now an array of the file size in bytes for each file, e.g.
        // [ 1000, 2000, 3000]
    }
    catch (err) {
        console.log(err);
    }
}

// Error Handling
async () => {
    try {
        let results = await async.map(withMissingFileList, getFileSizeInBytes);
        console.log(results);
    }
    catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    }
}