function autoInject(tasks, callback) {
        var newTasks = {};

        Object.keys(tasks).forEach(key => {
            var taskFn = tasks[key];
            var params;
            var fnIsAsync = isAsync(taskFn);
            var hasNoDeps =
                (!fnIsAsync && taskFn.length === 1) ||
                (fnIsAsync && taskFn.length === 0);

            if (Array.isArray(taskFn)) {
                params = [...taskFn];
                taskFn = params.pop();

                newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
            } else if (hasNoDeps) {
                // no dependencies, use the function as-is
                newTasks[key] = taskFn;
            } else {
                params = parseParams(taskFn);
                if ((taskFn.length === 0 && !fnIsAsync) && params.length === 0) {
                    throw new Error("autoInject task functions require explicit parameters.");
                }

                // remove callback param
                if (!fnIsAsync) params.pop();

                newTasks[key] = params.concat(newTask);
            }

            function newTask(results, taskCb) {
                var newArgs = params.map(name => results[name]);
                newArgs.push(taskCb);
                wrapAsync(taskFn)(...newArgs);
            }
        });

        return auto(newTasks, callback);
    }
A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
tasks are specified as parameters to the function, after the usual callback
parameter, with the parameter names matching the names of the tasks it
depends on. This can provide even more readable task graphs which can be
easier to maintain.

If a final callback is specified, the task results are similarly injected,
specified as named parameters after the initial error parameter.

The autoInject function is purely syntactic sugar and its semantics are
otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.

@name autoInject
@static
@memberOf module:ControlFlow
@method
@see [async.auto]{@link module:ControlFlow.auto}
@category Control Flow
@param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of
the form 'func([dependencies...], callback). The object's key of a property
serves as the name of the task defined by that property, i.e. can be used
when specifying requirements for other tasks.
* The `callback` parameter is a `callback(err, result)` which must be called
  when finished, passing an `error` (which can be `null`) and the result of
  the function's execution. The remaining parameters name other tasks on
  which the task is dependent, and the results from those tasks are the
  arguments of those parameters.
@param {Function} [callback] - An optional callback which is called when all
the tasks have been completed. It receives the `err` argument if any `tasks`
pass an error to their callback, and a `results` object with any completed
task results, similar to `auto`.
@returns {Promise} a promise, if no callback is passed
@example

//  The example from `auto` can be rewritten as follows:
async.autoInject({
    get_data: function(callback) {
        // async code to get some data
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        // async code to create a directory to store a file in
        // this is run at the same time as getting the data
        callback(null, 'folder');
    },
    write_file: function(get_data, make_folder, callback) {
        // once there is some data and the directory exists,
        // write the data to a file in the directory
        callback(null, 'filename');
    },
    email_link: function(write_file, callback) {
        // once the file is written let's email a link to it...
        // write_file contains the filename returned by write_file.
        callback(null, {'file':write_file, 'email':'user@example.com'});
    }
}, function(err, results) {
    console.log('err = ', err);
    console.log('email_link = ', results.email_link);
});

// If you are using a JS minifier that mangles parameter names, `autoInject`
// will not work with plain functions, since the parameter names will be
// collapsed to a single letter identifier.  To work around this, you can
// explicitly specify the names of the parameters your task function needs
// in an array, similar to Angular.js dependency injection.

// This still has an advantage over plain `auto`, since the results a task
// depends on are still spread into arguments.
async.autoInject({
    //...
    write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(write_file, callback) {
        callback(null, {'file':write_file, 'email':'user@example.com'});
    }]
    //...
}, function(err, results) {
    console.log('err = ', err);
    console.log('email_link = ', results.email_link);
});