function mapValues(obj, iteratee, callback) {
        return mapValuesLimit$1(obj, Infinity, iteratee, callback)
    }
A relative of [`map`]{@link module:Collections.map}, designed for use with objects.

Produces a new Object by mapping each value of `obj` through the `iteratee`
function. The `iteratee` is called each `value` and `key` from `obj` and a
callback for when it has finished processing. Each of these callbacks takes
two arguments: an `error`, and the transformed item from `obj`. If `iteratee`
passes an error to its callback, the main `callback` (for the `mapValues`
function) is immediately called with the error.

Note, the order of the keys in the result is not guaranteed.  The keys will
be roughly in the order they complete, (but this is very engine-specific)

@name mapValues
@static
@memberOf module:Collections
@method
@category Collection
@param {Object} obj - A collection to iterate over.
@param {AsyncFunction} iteratee - A function to apply to each value and key
in `coll`.
The iteratee should complete with the transformed value as its result.
Invoked with (value, key, callback).
@param {Function} [callback] - A callback which is called when all `iteratee`
functions have finished, or an error occurs. `result` is a new object consisting
of each key from `obj`, with each transformed value on the right-hand side.
Invoked with (err, result).
@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 fileMap = {
    f1: 'file1.txt',
    f2: 'file2.txt',
    f3: 'file3.txt'
};

const withMissingFileMap = {
    f1: 'file1.txt',
    f2: 'file2.txt',
    f3: 'file4.txt'
};

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

// Using callbacks
async.mapValues(fileMap, getFileSizeInBytes, function(err, result) {
    if (err) {
        console.log(err);
    } else {
        console.log(result);
        // result is now a map of file size in bytes for each file, e.g.
        // {
        //     f1: 1000,
        //     f2: 2000,
        //     f3: 3000
        // }
    }
});

// Error handling
async.mapValues(withMissingFileMap, getFileSizeInBytes, function(err, result) {
    if (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    } else {
        console.log(result);
    }
});

// Using Promises
async.mapValues(fileMap, getFileSizeInBytes)
.then( result => {
    console.log(result);
    // result is now a map of file size in bytes for each file, e.g.
    // {
    //     f1: 1000,
    //     f2: 2000,
    //     f3: 3000
    // }
}).catch (err => {
    console.log(err);
});

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

// Using async/await
async () => {
    try {
        let result = await async.mapValues(fileMap, getFileSizeInBytes);
        console.log(result);
        // result is now a map of file size in bytes for each file, e.g.
        // {
        //     f1: 1000,
        //     f2: 2000,
        //     f3: 3000
        // }
    }
    catch (err) {
        console.log(err);
    }
}

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