var bundle = require( '@stdlib/_tools/bundle/pkg-list' );

Bundles a list of packages into a single file.

var pkgs = [
    '@stdlib/math/base/special/erf',
    '@stdlib/math/base/special/gamma'
];

var opts = {
    'bundler': 'browserify',
    'paths': [
        '/path/to/stdlib/packages'
    ]
};

bundle( pkgs, opts, clbk );

function clbk( error, bundle ) {
    if ( error ) {
        throw error;
    }
    console.log( bundle.toString() );
}

The function accepts the following options:

• namespace: namespace format. Must be one of tree, flat, or none. Setting the option equal to tree indicates that the bundle should use a nested object namespace. A flat namespace uses the global project namespace, where each project package has a unique alias. A value of none indicates to forgo a namespace and require that each package be loaded independently. Default: tree.
• bundler: bundler. Default: 'browserify'.

The function accepts the following options which are specific to browserify:

• standalone: standalone browserify export name. Setting this option instructs the function to generate a UMD bundle with the supplied export name. The generated bundle will work with other module systems. If no module system is found, the export name is attached to the window global.
• exportName: bundle export target. The target is the name used to load the bundle from the external environment. In contrast to a standalone UMD bundle, a require function is exposed as a global variable. Default: @stdlib/stdlib.
• requireName: name of function exposed to support external loading of modules from a browserify bundle. Default: require.
• transforms: an array of browserify transform modules and functions (including corresponding options) to be applied during bundling.
• plugins: an array of browserify plugins (including corresponding options) to be applied during bundling.
• external: an array of modules to omit when generating a bundle. Omitted modules are assumed to be present in a separate external bundle.
• paths: an array of directory paths in which to search for modules referenced via non-relative paths. By default, the function searches the current working directory and the paths extracted from the NODE_PATH environment variable. In order to search specific directories (e.g., in non-project developer environments or in environments in which the NODE_PATH variable has not been set), explicitly set this option.

• Unless a package namespace has an alias in the global alias namespace (e.g., @stdlib/datasets => datasets), namespaces are not included in either flat or tree namespace bundles. If namespace packages were allowed in flat namespace bundles, flat namespace bundles would have mixed namespaces, which is not desired (e.g., possibility of having multiple ways to access the same bundle value). If namespace packages were allowed in tree namespace bundles, tree namespace bundles may attempt to override namespace properties which are read-only. If you want a namespace, provide a namespace only, no namespace children, and generate a tree namespace bundle. And if you only want certain children, then provide the children, but not the namespace. Providing both signals confusion.
• If the bundler is browserify and the intent is to include the bundle within another bundle (e.g., via require), you may need to use a browserify plugin, such as browserify-derequire, in order to rename require calls and thus preserve the ability of the embedded bundle to resolve its bundled modules. Otherwise, require calls may attempt to resolve modules from the wrong bundle.