Configuration Options

webpack is configured with an options object, usually exported from a webpack.config.js file. Every build validates that object against the options schema (schemas/WebpackOptions.json), so unknown or malformed options fail with a descriptive error. This page is generated from that schema and lists every supported option; named types link to their full definitions in the API documentation.

Set the value of require.amd and define.amd. Or disable AMD support.

Report the first error as a hard error instead of tolerating it.

Cache generated modules and chunks to improve performance for multiple incremental builds.

The base directory (absolute path!) for resolving the entry option. If output.pathinfo is set, the included pathinfo is shortened to this directory.

References to other configurations to depend on.

Options for the webpack-dev-server.

A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).

Enable and configure the Dotenv plugin to load environment variables from .env files.

The directory from which .env files are loaded. Can be an absolute path, false will disable the .env file loading.

Only expose environment variables that start with these prefixes. Defaults to 'WEBPACK_'.

Template patterns for .env file names. Use [mode] as placeholder for the webpack mode. Defaults to ['.env', '.env.local', '.env.[mode]', '.env.[mode].local'].

The entry point(s) of the compilation.

Enables/Disables experiments (experimental features with relax SemVer compatibility).

Support WebAssembly as asynchronous EcmaScript Module.

Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.

Build http(s): urls using a lockfile and resource content cache.

Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.

Enable css support.

Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.

Apply defaults of next major version.

Enable experimental HTML support. This flag does not by itself make .html files usable directly as entry points without additional HTML handling.

Compile entrypoints and import()s only when they are accessed.

Allow output javascript files as module source type.

Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.

Support WebAssembly as synchronous EcmaScript Module (outdated).

Enable typescript support.

Extend configuration from another configuration (only works when using webpack-cli).

Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on output.libraryTarget.

Specify externals depending on the layer.

Enable presets of externals for specific targets.

Treat common electron built-in modules in main and preload context like 'electron', 'ipc' or 'shell' as external and load them via require() when used.

Treat electron built-in modules in the main context like 'app', 'ipc-main' or 'shell' as external and load them via require() when used.

Treat electron built-in modules in the preload context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.

Treat electron built-in modules in the renderer context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.

Treat node.js built-in modules like fs, path or vm as external and load them via require() when used.

Treat NW.js legacy nw.gui module as external and load it via require() when used.

Treat references to 'http(s)://...' and 'std:...' as external and load them via import when used (Note that this changes execution order as externals are executed before any other code in the chunk).

Treat references to 'http(s)://...' and 'std:...' as external and load them via async import() when used (Note that this external type is an async module, which has various effects on the execution).

Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).

Ignore specific warnings.

Options for infrastructure level logging.

Only appends lines to the output. Avoids updating existing output e. g. for status messages. This option is only used when no custom console is provided.

Enables/Disables colorful output. This option is only used when no custom console is provided.

Custom console used for logging.

Enable debug logging for specific loggers.

Log level.

Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.

Custom values available in the loader context.

Enable production optimizations or development hints.

Options affecting the normal modules (NormalModuleFactory).

An array of rules applied by default for modules.

Enable warnings for full dynamic dependencies.

Enable recursive directory lookup for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRecursive'.

Sets the default regular expression for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRegExp'.

Set the default request for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRequest'.

Specify options for each generator.

Don't parse files matching. It's matched against the full resolved request.

Specify options for each parser.

An array of rules applied for modules.

Emit errors instead of warnings when imported names don't exist in imported module. Deprecated: This option has moved to 'module.parser.javascript.strictExportPresence'.

Handle the this context correctly according to the spec for namespace objects. Deprecated: This option has moved to 'module.parser.javascript.strictThisContextOnImports'.

Enable warnings when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextCritical'.

Enable recursive directory lookup when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRecursive'.

Sets the regular expression when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRegExp'.

Sets the request when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRequest'.

Cache the resolving of module requests.

Enable warnings for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextCritical'.

Enable recursive directory lookup for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRecursive'.

Set the inner regular expression for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRegExp'.

Name of the configuration. Used when loading multiple configurations.

Include polyfills or mocks for various node stuff.

Include a polyfill for the '__dirname' variable.

Include a polyfill for the '__filename' variable.

Include a polyfill for the 'global' variable.

Enables/Disables integrated optimizations.

Avoid wrapping the entry module in an IIFE.

Check for incompatible wasm types when importing/exporting from/to ESM.

Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).

Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer.

Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.

Also flag chunks as loaded which contain a subset of the modules.

Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.

Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).

Reduce size of WASM by changing imports to shorter strings.

Merge chunks which contain the same modules.

Enable minimizing the output. Uses optimization.minimizer.

Minimizer(s) to use for minimizing the output.

Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).

Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).

Set process.env.NODE_ENV to a specific value.

Generate records with relative paths to be able to move the context folder.

Figure out which exports are provided by modules to generate more efficient code.

Use real [contenthash] based on final content of the assets.

Removes modules from chunks when these modules are already included in all parents.

Remove chunks which are empty.

Create an additional chunk which contains only the webpack runtime and chunk hash maps.

Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).

Optimize duplication and caching by splitting chunks by shared modules and cache group.

Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).

Options affecting the output of the compilation. output options tell webpack how to write the compiled files to disk.

The filename of asset modules as relative path inside the 'output.path' directory.

Enable/disable creating async chunks that are loaded on demand.

Add charset attribute for script tag.

Specifies the filename template of output files of non-initial chunks on disk. You must not specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.

The format of chunks (formats included by default are 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but others might be added by plugins).

Number of milliseconds before chunk request expires.

The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).

The global variable used by webpack for loading of chunks.

Clean the output directory before emit.

Check if to be emitted file already exists and have the same content before writing to output filesystem.

This option enables cross-origin loading of chunks.

Specifies the filename template of non-initial output css files on disk. You must not specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.

Specifies the filename template of output css files on disk. You must not specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.

Similar to output.devtoolModuleFilenameTemplate, but used in the case of duplicate module identifiers.

Filename template string of function for the sources array in a generated SourceMap.

Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to output.library if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.

List of chunk loading types enabled for use by entry points.

List of library types enabled for use by entry points.

List of wasm loading types enabled for use by entry points.

The abilities of the environment where the webpack generated code should run.

Specifies the filename of output files on disk. You must not specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.

An expression which is used to address the global object/scope in runtime code.

Digest types used for the hash.

Number of chars which are used for the hash.

Algorithm used for generation the hash (see node.js crypto package).

Any string which is added to the hash to salt it.

The filename of the Hot Update Chunks. They are inside the output.path directory.

The global variable used by webpack for loading of hot update chunks.

The filename of the Hot Update Main File. It is inside the 'output.path' directory.

Specifies the filename template of non-initial output html files on disk. You must not specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.

Specifies the filename template of output html files on disk. You must not specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.

Ignore warnings in the browser.

Wrap javascript code into IIFE's to avoid leaking into global scope.

The name of the native import() function (can be exchanged for a polyfill).

The name of the native import.meta object (can be exchanged for a polyfill).

Make the output files a library, exporting the exports of the entry point.

Output javascript files as module source type.

The output directory as absolute path (required).

Include comments with information about the modules.

The 'publicPath' specifies the public URL address of the output files when referenced in a browser.

This option enables loading async chunks via a custom script type, such as script type="module".

The filename of the SourceMaps for the JavaScript files. They are inside the 'output.path' directory.

Prefixes every line of the source in the bundle with this string.

Handles error in module loading correctly at a performance cost. This will handle module error compatible with the EcmaScript Modules spec.

Handles exceptions in module loading correctly at a performance cost (Deprecated). This will handle module error compatible with the Node.js CommonJS way.

Use a Trusted Types policy to create urls for chunks. 'output.uniqueName' is used a default policy name. Passing a string sets a custom policy name.

A unique name of the webpack build to avoid multiple webpack runtimes to conflict when using globals.

The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).

The filename of WebAssembly modules as relative path inside the 'output.path' directory.

The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).

Worker public path. Much like the public path, this sets the location where the worker script file is intended to be found. If not set, webpack will use the publicPath. Don't set this option unless your worker scripts are located at a different path from your other script files.

The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).

The number of parallel processed modules in the compilation.

Configuration for web performance recommendations.

Filter function to select assets that are checked.

Sets the format of the hints: warnings, errors or nothing at all.

File size limit (in bytes) when exceeded, that webpack will provide performance hints.

Total size of an entry point (in bytes).

Add additional plugins to the compiler.

Capture timing information for each module.

Store compiler state to a json file.

Load compiler state from a json file.

Store/Load compiler state from/to a json file. This will result in persistent ids of modules and chunks. An absolute path is expected. recordsPath is used for recordsInputPath and recordsOutputPath if they left undefined.

Options for the resolver.

Redirect module requests.

Fields in the description file (usually package.json) which are used to redirect requests inside the module.

Extra resolve options per dependency category. Typical categories are "commonjs", "amd", "esm".

Enable caching of successfully resolved requests (cache entries are revalidated).

Predicate function to decide which requests should be cached.

Include the context information in the cache identifier when caching.

Condition names for exports field entry point.

Filenames used to find a description file (like a package.json).

Enforce the resolver to use one of the extensions from the extensions option (User must specify requests without extension).

Field names from the description file (usually package.json) which are used to provide entry points of a package.

An object which maps extension to extension aliases.

Extensions added to the request when trying to find the file.

Redirect module requests when normal resolving fails.

Filesystem for the resolver.

Treats the request specified by the user as fully specified, meaning no extensions are added and the mainFiles in directories are not resolved (This doesn't affect requests from mainFields, aliasFields or aliases).

Field names from the description file (usually package.json) which are used to provide internal request of a package (requests starting with # are considered as internal).

Field names from the description file (package.json) which are used to find the default entry point.

Filenames used to find the default entry point if there is no description file or main field.

Folder names or directory paths where to find modules.

Plugins for the resolver.

Prefer to resolve server-relative URLs (starting with '/') as absolute paths before falling back to resolve in 'resolve.roots'.

Prefer to resolve module requests as relative request and fallback to resolving as module.

Custom resolver.

A list of resolve restrictions. Resolve results must fulfill all of these restrictions to resolve successfully. Other resolve paths are taken when restrictions are not met.

A list of directories in which requests that are server-relative URLs (starting with '/') are resolved.

Enable resolving symlinks to the original location.

TypeScript config for paths mapping. Can be false (disabled), true (use default tsconfig.json), a string path to tsconfig.json, or an object with configFile and references options.

Enable caching of successfully resolved requests (cache entries are not revalidated).

Use synchronous filesystem calls for the resolver.

Options for the resolver when resolving loaders.

Redirect module requests.

Fields in the description file (usually package.json) which are used to redirect requests inside the module.

Extra resolve options per dependency category. Typical categories are "commonjs", "amd", "esm".

Enable caching of successfully resolved requests (cache entries are revalidated).

Predicate function to decide which requests should be cached.

Include the context information in the cache identifier when caching.

Condition names for exports field entry point.

Filenames used to find a description file (like a package.json).

Enforce the resolver to use one of the extensions from the extensions option (User must specify requests without extension).

Field names from the description file (usually package.json) which are used to provide entry points of a package.

An object which maps extension to extension aliases.

Extensions added to the request when trying to find the file.

Redirect module requests when normal resolving fails.

Filesystem for the resolver.

Treats the request specified by the user as fully specified, meaning no extensions are added and the mainFiles in directories are not resolved (This doesn't affect requests from mainFields, aliasFields or aliases).

Field names from the description file (usually package.json) which are used to provide internal request of a package (requests starting with # are considered as internal).

Field names from the description file (package.json) which are used to find the default entry point.

Filenames used to find the default entry point if there is no description file or main field.

Folder names or directory paths where to find modules.

Plugins for the resolver.

Prefer to resolve server-relative URLs (starting with '/') as absolute paths before falling back to resolve in 'resolve.roots'.

Prefer to resolve module requests as relative request and fallback to resolving as module.

Custom resolver.

A list of resolve restrictions. Resolve results must fulfill all of these restrictions to resolve successfully. Other resolve paths are taken when restrictions are not met.

A list of directories in which requests that are server-relative URLs (starting with '/') are resolved.

Enable resolving symlinks to the original location.

TypeScript config for paths mapping. Can be false (disabled), true (use default tsconfig.json), a string path to tsconfig.json, or an object with configFile and references options.

Enable caching of successfully resolved requests (cache entries are not revalidated).

Use synchronous filesystem calls for the resolver.

Options affecting how file system snapshots are created and validated.

Options for snapshotting build dependencies to determine if the whole cache need to be invalidated.

Options for snapshotting the context module to determine if it needs to be built again.

List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable.

List of paths that are managed by a package manager and can be trusted to not be modified otherwise.

Options for snapshotting dependencies of modules to determine if they need to be built again.

Options for snapshotting dependencies of request resolving to determine if requests need to be re-resolved.

Options for snapshotting the resolving of build dependencies to determine if the build dependencies need to be re-resolved.

List of paths that are not managed by a package manager and the contents are subject to change.

Stats options object or preset name.

Fallback value for stats options when an option is not defined (has precedence over local webpack defaults).

Add assets information.

Sort the assets by that field.

Space to display assets (groups will be collapsed to fit this space).

Add built at time information.

Add information about cached (not built) modules (deprecated: use 'cachedModules' instead).

Show cached assets (setting this to false only shows emitted files).

Add information about cached (not built) modules.

Add children information.

Display auxiliary assets in chunk groups.

Display children of chunk groups.

Limit of assets displayed in chunk groups.

Display all chunk groups with the corresponding bundles.

Add built modules information to chunk information.

Space to display chunk modules (groups will be collapsed to fit this space, value is in number of modules/group).

Add the origins of chunks and chunk merging info.

Add information about parent, children and sibling chunks to chunk information.

Add chunk information.

Sort the chunks by that field.

Enables/Disables colorful output.

Context directory for request shortening.

Show chunk modules that are dependencies of other modules of the chunk.

Add module depth in module graph.

Display the entry points with the corresponding bundles.

Add --env information.

Add cause to errors.

Add details to errors (like resolving log).

Add nested errors to errors (like in AggregateError).

Add internal stack trace to errors.

Add errors.

Add errors count.

Space to display errors (value is in number of lines).

Please use excludeModules instead.

Suppress assets that match the specified filters. Filters can be Strings, RegExps or Functions.

Suppress modules that match the specified filters. Filters can be Strings, RegExps, Booleans or Functions.

Group assets by how their are related to chunks.

Group assets by their status (emitted, compared for emit or cached).

Group assets by their extension.

Group assets by their asset info (immutable, development, hotModuleReplacement, etc).

Group assets by their path.

Group modules by their attributes (errors, warnings, assets, optional, orphan, or dependent).

Group modules by their status (cached or built and cacheable).

Group modules by their extension.

Group modules by their layer.

Group modules by their path.

Group modules by their type.

Group reasons by their origin module.

Add the hash of the compilation.

Add ids.

Add logging output.

Include debug logging of specified loggers (i. e. for plugins or loaders). Filters can be Strings, RegExps or Functions.

Add stack traces to logging output.

Add information about assets inside modules.

Add dependencies and origin of warnings/errors.

Add built modules information.

Sort the modules by that field.

Space to display modules (groups will be collapsed to fit this space, value is in number of modules/groups).

Add information about modules nested in other modules (like with module concatenation).

Space to display modules nested within other modules (groups will be collapsed to fit this space, value is in number of modules/group).

Show reasons why optimization bailed out for modules.

Add information about orphan modules.

Add output path information.

Add performance hint flags.

Preset for the default values.

Show exports provided by modules.

Add public path information.

Add information about the reasons why modules are included.

Space to display reasons (groups will be collapsed to fit this space).

Add information about assets that are related to other assets (like SourceMaps for assets).

Add information about runtime modules (deprecated: use 'runtimeModules' instead).

Add information about runtime modules.

Add the source code of modules.

Add timing information.

Show exports used by modules.

Add webpack version information.

Add warnings.

Add warnings count.

Suppress listing warnings that match the specified filters (they will still be counted). Filters can be Strings, RegExps or Functions.

Space to display warnings (value is in number of lines).

Environment to build for. An array of environments to build for all of them when possible.

Enable validation of webpack configuration. Defaults to true in development mode. In production mode, defaults to true unless futureDefaults is enabled, then defaults to false.

Enter watch mode, which rebuilds on file change.

Options for the watcher.

Delay the rebuilt after the first change. Value is a time in ms.

Resolve symlinks and watch symlink and real file. This is usually not needed as webpack already resolves symlinks ('resolve.symlinks').

Ignore some files from watching (glob pattern or regexp).

Enable polling mode for watching.

Stop watching when stdin stream has ended.