Interface OutputOptions

Allows you to do manual chunking. For deeper understanding, please refer to the in-depth documentation.

• Type: boolean
• Default: false

Clean output directory before emitting output.

Expected format of generated code.

• 'es', 'esm' and 'module' are the same format, all stand for ES module.
• 'cjs' and 'commonjs' are the same format, all stand for CommonJS module.
• 'iife' stands for Immediately Invoked Function Expression.
• 'umd' stands for Universal Module Definition.

Keep function and class names after bundling.

When enabled, the bundler will preserve the original names of functions and classes in the output, which is useful for debugging and error stack traces.

Control comments in the output.

• none: no comments
• inline: preserve comments that contain @license, @preserve or starts with //! /*!

• Type: ((moduleId: string, meta: { getModuleInfo: (moduleId: string) => ModuleInfo | null }) => string | NullValue)
• Object form is not supported.

:::warning

• This option is deprecated. Please use advancedChunks instead.
• If manualChunks and advancedChunks are both specified, manualChunks option will be ignored. :::

You could use this option for migration purpose. Under the hood,

{
  manualChunks: (moduleId, meta) => {
    if (moduleId.includes('node_modules')) {
      return 'vendor';
    }
    return null;
  }
}
Copy

will be transformed to

{
  advancedChunks: {
    groups: [
      {
        name(moduleId) {
          if (moduleId.includes('node_modules')) {
            return 'vendor';
          }
          return null;
        },
      },
    ],
  }
}

Copy

Control code minification.

• true: Enable full minification including code compression and dead code elimination
• false: Disable minification (default)
• 'dce-only': Only perform dead code elimination without code compression
• MinifyOptions: Fine-grained control over minification settings

• Type: boolean
• Default: true for format es or if output.minify is true or object, false otherwise

Whether to minify internal exports.

Maps external module IDs to paths.

Allows customizing the path used when importing external dependencies. This is particularly useful for loading dependencies from CDNs or custom locations.

• Object form: Maps module IDs to their replacement paths
• Function form: Takes a module ID and returns its replacement path

Similar to banner option, but will run after the renderChunk hook and builtin minification.

Similar to footer option, but will run after the renderChunk hook and builtin minification.

Control which source files are included in the sourcemap ignore list. Files in the ignore list are excluded from debugger stepping and error stack traces.

• false: Include all source files in the ignore list
• true: Include no source files in the ignore list
• string: Files containing this string in their path will be included in the ignore list
• RegExp: Files matching this regular expression will be included in the ignore list
• function: Custom function (source: string, sourcemapPath: string) => boolean to determine if a source should be ignored

:::tip Performance Using static values (boolean, string, or RegExp) is significantly more performant than functions. Calling JavaScript functions from Rust has extremely high overhead, so prefer static patterns when possible. :::

Examples

// ✅ Preferred: Use RegExp for better performance
sourcemapIgnoreList: /node_modules/

// ✅ Preferred: Use string pattern for better performance
sourcemapIgnoreList: "vendor"

// ! Use sparingly: Function calls have high overhead
sourcemapIgnoreList: (source, sourcemapPath) => {
  return source.includes('node_modules') || source.includes('.min.');
}
Copy

default: /node_modules/