Skip to content

Interface: OutputOptions

Properties

advancedChunks?

  • Type: optional advancedChunks: object

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

groups?

  • Type: optional groups: object[]

Groups to be used for advanced chunking.

includeDependenciesRecursively?

  • Type: optional includeDependenciesRecursively: boolean

  • Type: boolean

  • Default: true

By default, each group will also include captured modules' dependencies. This reduces the chance of generating circular chunks.

If you want to disable this behavior, it's recommended to both set

  • preserveEntrySignatures: false | 'allow-extension'
  • strictExecutionOrder: true

to avoid generating invalid chunks.

maxModuleSize?

  • Type: optional maxModuleSize: number

  • Type: number

Global fallback of {group}.maxModuleSize, if it's not specified in the group.

maxSize?

  • Type: optional maxSize: number

  • Type: number

Global fallback of {group}.maxSize, if it's not specified in the group.

minModuleSize?

  • Type: optional minModuleSize: number

  • Type: number

Global fallback of {group}.minModuleSize, if it's not specified in the group.

minShareCount?

  • Type: optional minShareCount: number

  • Type: number

Global fallback of {group}.minShareCount, if it's not specified in the group.

minSize?

  • Type: optional minSize: number

  • Type: number

Global fallback of {group}.minSize, if it's not specified in the group.


assetFileNames?

  • Type: optional assetFileNames: string | AssetFileNamesFunction


chunkFileNames?


cleanDir?

  • Type: optional cleanDir: boolean
  • Type: boolean
  • Default: false

Clean output directory before emitting output.


cssChunkFileNames?


cssEntryFileNames?


dir?

  • Type: optional dir: string

entryFileNames?


esModule?

  • Type: optional esModule: boolean | "if-default-prop"

exports?

  • Type: optional exports: "auto" | "named" | "default" | "none"

extend?

  • Type: optional extend: boolean

externalLiveBindings?

  • Type: optional externalLiveBindings: boolean

file?

  • Type: optional file: string


format?

Expected format of generated code.

Default

ts
'esm'

generatedCode?


globals?


hashCharacters?

  • Type: optional hashCharacters: "base64" | "base36" | "hex"

hoistTransitiveImports?

  • Type: optional hoistTransitiveImports: false

inlineDynamicImports?

  • Type: optional inlineDynamicImports: boolean

intro?


keepNames?

  • Type: optional keepNames: boolean

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.

Default

ts
false

legalComments?

  • Type: optional legalComments: "none" | "inline"

Control comments in the output.

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

manualChunks?

  • Type: optional manualChunks: ManualChunksFunction
  • 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,

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

will be transformed to

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

Deprecated

Please use advancedChunks instead.


minify?

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

Default

ts
false

minifyInternalExports?

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

Whether to minify internal exports.


name?

  • Type: optional name: string

outro?


paths?

  • Type: optional paths: Record<string, string> | PathsFunction

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

Examples

js
{
  paths: {
    'd3': 'https://cdn.jsdelivr.net/npm/d3@7'
  }
}
js
{
  paths: (id) => {
    if (id.startsWith('lodash')) {
      return `https://cdn.jsdelivr.net/npm/${id}`
    }
    return id
  }
}

plugins?

  • Type: optional plugins: RolldownOutputPluginOption

polyfillRequire?

  • Type: optional polyfillRequire: boolean

postBanner?

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


postFooter?

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


preserveModules?

  • Type: optional preserveModules: boolean

preserveModulesRoot?

  • Type: optional preserveModulesRoot: string

sanitizeFileName?

  • Type: optional sanitizeFileName: boolean | SanitizeFileNameFunction

sourcemap?

  • Type: optional sourcemap: boolean | "inline" | "hidden"

sourcemapBaseUrl?

  • Type: optional sourcemapBaseUrl: string

sourcemapDebugIds?

  • Type: optional sourcemapDebugIds: boolean

sourcemapIgnoreList?

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

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

js
// ✅ 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.');
}

default: /node_modules/


sourcemapPathTransform?

  • Type: optional sourcemapPathTransform: SourcemapPathTransformOption

topLevelVar?

  • Type: optional topLevelVar: boolean

virtualDirname?

  • Type: optional virtualDirname: string

Released under the MIT License.