配置选项

如果某些插件在 buildStart 钩子结束前至少生成了一个 chunk（使用 this.emitFile ），则该选项可以省略。

当使用命令行时，多个入口只需要多次使用该选项输入。当作为第一个选项提供时，相当于不以 --input 为前缀：

rollup --format es --input src/entry1.js --input src/entry2.js
# 等同于
rollup src/entry1.js src/entry2.js --format es

可以使用 = 赋值来命名 chunk：

rollup main=src/entry1.js other=src/entry2.js --format es

可以使用引号指定包含空格的文件名：

rollup "main entry"="src/entry 1.js" "src/other entry.js" --format es

output.dir ​

该选项用于指定所有生成的 chunk 被放置在哪个目录中。如果生成一个以上的 chunk，那么这个选项是必需的。否则，可以使用 file 选项来代替。

output.file ​

该选项用于指定要写入的文件。如果适用的话，也可以用于生成 sourcemap。只有在生成的 chunk 不超过一个的情况下才可以使用。

output.format ​

该选项用于指定生成的 bundle 的格式。满足以下其中之一：

• amd – 异步模块加载，适用于 RequireJS 等模块加载器
• cjs – CommonJS，适用于 Node 环境和其他打包工具（别名： commonjs ）
• es – 将 bundle 保留为 ES 模块文件，适用于其他打包工具，以及支持 <script type=module> 标签的浏览器。（别名： esm ， module ）
• iife – 自执行函数，适用于 <script> 标签（如果你想为你的应用程序创建 bundle，那么你可能会使用它）。 iife 表示“自执行 函数表达式 ”
• umd – 通用模块定义规范，同时支持 amd ， cjs 和 iife
• system – SystemJS 模块加载器的原生格式（别名： systemjs ）

output.globals ​

该选项用于在 umd / iife bundle 中，使用 id: variableName 键值对指定外部依赖。例如，在这样的情况下：

import $ from 'jquery';

我们需要告诉 Rollup jquery 是外部依赖， jquery 模块的 ID 为全局变量 $ ：

// rollup.config.js
export default {
	// ...
	
external
: ['jquery'],
	
output
: {
		
format
: 'iife',
		
name





    
: 'MyBundle',
		
globals
: {
			
jquery
: '$'
var MyBundle = (function ($) {
  // 这里编辑代码
}($));
*/

或者，可以提供一个函数，将外部模块的 ID 变成一个全局变量名。

当作为命令行参数时，该选项的值应该是以逗号分隔的 id:variableName 键值对列表：

rollup -i src/main.js ... -g jquery:$,underscore:_

要告诉 Rollup 用全局变量替换本地文件时，请使用一个绝对路径的 ID。

// rollup.config.js
import { 
fileURLToPath
 } from 'node:url';
const 
externalId
 = 
fileURLToPath
(
	new 
URL
(
		'src/some-local-file-that-should-not-be-bundled.js',
		import.meta.
url

export default {
	//...,
	
external
: [
externalId
],
	
output
: {
		
format
: 'iife',
		
name
: 'MyBundle',
		
globals
: {
			[
externalId
]: 'globalVariable'
};




    

output.name ​

对于输出格式为 iife / umd 的 bundle 来说，若想要使用全局变量名来表示你的 bundle 时，该选项是必要的。同一页面上的其他脚本可以使用这个变量名来访问你的 bundle 输出。

// rollup.config.js
export default {
	// ...
	
output
: {
		
file
: 'bundle.js',
		
format
: 'iife',
		
name
: 'MyBundle'
// var MyBundle = (function () {...

该选项也支持命名空间，即可以包含点 . 的名字。最终生成的 bundle 将包含命名空间所需要的设置。

rollup -n "a.b.c"
this.a = this.a || {};
this.a.b = this.a.b || {};
this.a.b.c = ...
*/

output.plugins ​

该选项用于指定输出插件。关于如何使用特定输出的插件，请查看 使用输出插件 ，关于如何编写自己的插件，请查看 插件 。对于从包中引入的插件，记得要调用引入的插件函数（即调用 commonjs() ，而不仅仅是 commonjs ）。返回值为假的插件将被忽略，这样可以用来灵活启用或禁用插件。嵌套的插件将扁平化。异步插件将等待和被解决。

并非所有的插件都可以通过该选项使用。 output.plugins 仅限于在 bundle.generate() 或 bundle.write() 阶段，即在 Rollup 的主要分析完成后运行钩子的插件才可使用。如果你是一个插件作者，请查看 输出生成钩子 章节以了解哪些钩子可以使用。

以下是一个使用压缩插件作用于其中一个输出的例子：

// rollup.config.js
import 
terser
 from '@rollup/plugin-terser';
export default {
	
input
: 'main.js',
	
output
: [
			
file





    
: 'bundle.js',
			
format
: 'es'
			
file
: 'bundle.min.js',
			
format
: 'es',
			
plugins
: [
terser
()]
};

plugins ​

关于如何使用插件的更多信息，请查看 使用插件 章节，关于如何编写你自己的插件，请查看 插件 章节（试试看吧，它并不像听起来那么困难，你可以通过 Rollup 插件做很多拓展）。对于从包中引入的插件，记住要调用引入的插件函数（即调用 commonjs() ，而不仅仅是 commonjs ）。返回值为假的插件将被忽略，这样可以用来灵活启用或禁用插件。嵌套的插件将扁平化。异步插件将等待和被解决。

// rollup.config.js
import 
resolve
 from '@rollup/plugin-node-resolve';
import 
commonjs
 from '@rollup/plugin-commonjs';
const 
isProduction
 = 
process
.
env
.
NODE_ENV
 === 'production';
export default (async () => ({
	
input
: 'main.js',
	
plugins
: [
		
resolve





    
(),
		
commonjs
(),
		
isProduction
 && (await import('@rollup/plugin-terser')).
default
()
	
output
: {
		
file
: 'bundle.js',
		
format
: 'cjs'
}))();

（上述例子还演示了如何使用一个异步 IIFE 和动态引入来避免引入不必要的模块，这可能会使打包过程变慢。）

进阶功能 ​

cache ​

该选项用于指定之前 bundle 的 cache 属性。使用该设置，Rollup 将只会对改变的模块重新分析，从而加速观察模式中后续的构建。将此选项明确设置为 false 将阻止 bundle 生成 cache 属性，也将导致插件的缓存失效。

const 
rollup
 = 
require
('rollup');
let 
cache
;
async function 
buildWithCache
() {
	const 
bundle
 = await 
rollup
.
rollup
({
		
cache





    
 // 如果值为假，则忽略
		// ... 其他输入项
	
cache
 = 
bundle
.
cache
; // 保存之前构建的缓存对象
	return 
bundle
;
buildWithCache
()
	.
then
(
bundle
 => {
		// ... 操作 bundle
	.
then
(() => 
buildWithCache
()) // 将使用之前构建的缓存
	.
then
(
bundle
 => {
		// ... 操作 bundle
	});

logLevel ​

该选项决定哪些日志将被处理。查看 onLog 以了解可用的日志级别。默认的 logLevel 为 "info" ，这意味着 info 和 warning 日志将被处理，而 debug 日志将被忽略，这意味着它们既不会传递给插件 onLog 钩子，也不会传递给 onLog 选项或打印到控制台。

当使用命令行时，错误日志仍将打印到控制台，因为它们不会通过日志系统处理。查看 --silent 标志以了解如何抑制错误日志。

makeAbsoluteExternalsRelative ​

该选项决定外部依赖的绝对路径是否应该在输出中转换为相对路径。本选项不仅适用于源文件中的绝对路径，也适用于由插件或 Rollup 核心解析出的绝对路径。

值为 true 时，像 import "/Users/Rollup/project/relative.js" 这样的外部引入将被转换为相对路径。当把绝对路径转换为相对路径时，Rollup 不考虑 file 或 dir 选项，因为这些选项可能不存在，比如在使用 JavaScript API 的构建中。相反，它假设输出 bundle 的根目录位于 bundle 中包含的所有模块的同一父目录。比如说所有模块的公共父目录是 "/Users/Rollup/project" ，上面的引入可能会在输出中被转换为 import "./relative.js" 。如果输出 chunk 本身是嵌套在一个子目录中，通过设置例如 chunkFileNames: "chunks/[name].js" ，那么引入将会转换为 "../relative.js" 。

如上所述，这也适用于最初的相对引入，如 import "./relative.js" ，在被 external 选项标记为外部依赖之前会被解析为绝对路径。

一个常见的问题是，这种机制也会适用于像 import "/absolute.js'" 这样的引入，导致输出中出现意外的相对路径。

对于这种情况，设置为 "ifRelativeSource" 可以检查原始引入是否是相对引入，然后在输出时才将其转换为相对引入。设置为 false 将在输出时保持所有路径为绝对路径。

请注意，当一个相对路径使用 external 选项直接标记为 "外部依赖" 时，那么它在输出时会是相同的相对路径。当它通过插件或 Rollup 核心解析，然后标记为外部依赖后，上述逻辑将适用。

maxParallelFileOps ​

该选项限制 rollup 在读取模块或写入 chunk 时，同时能打开的文件数量。如果没有限制或者数值足够高，构建可能会失败，显示“EMFILE: Too many open files”（EMFILE：打开的文件数过多）。这取决于操作系统限制的句柄数（open file handles）大小。

onLog ​

type LogLevel = 'warn' | 'info' | 'debug';
type LogOrStringHandler = (
	level: LogLevel | 'error',
	log: string | RollupLog
) => void;
// 所有可能的属性，实际的属性都取决 log
interface RollupLog {
	binding?: string;
	cause?: Error;
	code?: string;
	exporter?: string;
	frame?: string; // 始终会被 CLI 打印出来
	hook?: string;
	id?: string; // 始终会被 CLI 打印出来
	ids?: string[];
	loc?: {
		column: number;
		file?: string;
		line: number;
	}; // 只要 id 存在，就始终会被 CLI 打印出来
	message: string; // 实际信息，始终会被 CLI 打印出来
	meta?: any; // add custom plugin properties to logs
	names?: string[];
	plugin?: string; // added by Rollup for plugin logs, only printed for warnings
	pluginCode?: string; // added by Rollup for plugin logs that contain a code
	pos?: number;
	reexporter?: string;
	stack?: string; // url for additional information, always printed by the CLI
	url?: string;
}

一个用于截取日志信息的函数。如果未提供，日志将打印到控制台，其中 Rollup CLI 会聚合某些 "warn" 日志，并在构建完成后打印汇总的警告，以减少干扰。当使用 --silent 命令行选项时，也会触发此处理程序。

该函数接收三个参数：日志级别、日志对象和默认处理程序。日志对象至少有一个 code 和一个 message 属性，允许你控制如何处理不同类型的日志。其他属性根据日志类型添加。参见 utils/logs.ts ，查看内置错误和日志的完整列表，以及它们的代码和属性。

如果不调用默认处理程序，日志将不会打印到控制台。此外，您可以通过调用不同级别的默认处理程序来改变日志级别。使用附加级别 "error" 将把日志转换为一个抛出的错误，该错误具有附加的所有日志属性。

// rollup.config.js
export default {
	//...
	
onLog
(
level
, 
log
, 
handler
) {
		if (
log
.
code
 === 'CIRCULAR_DEPENDENCY') {
			return; // 忽略循环依赖警告
		if (
level
 === 'warn') {
			
handler
('error', 
log
); // 将其他警告转为错误
		} else {
			
handler
(
level
, info); // 否则直接打印出日志
};

这个处理程序不会在日志被 logLevel 选项过滤掉时被调用。例如，默认情况下， "debug" 日志将被忽略。

一些日志也有 loc 和 frame 属性，允许你定位日志的源：

// rollup.config.js
export default {
	//...
	
onLog





    
(
level
, { 
loc
, 
frame
, 
message
 }) {
		if (
loc
) {
			
console
.
warn
(`${
loc
.
file
} (${
loc
.
line
}:${
loc
.
column
}) ${
message
}`);
			if (
frame
) 
console
.
warn
(
frame
);
		} else {
			
console





    
.
warn
(
message
);
};

onwarn ​

一个函数，用于拦截警告信息。它与 onLog 非常相似，但只接收警告。如果调用默认处理程序，日志将被处理为警告。如果提供了 onLog 和 onwarn 处理程序，只有当 onLog 调用其默认处理程序时， onwarn 处理程序才会被调用，且 level 为 warn 。

查看 onLog 了解更多信息

output.assetFileNames ​

interface PreRenderedAsset {
	name: string | undefined;
	originalFileName: string | null;
	source: string | Uint8Array;
	type: 'asset';
}

该选项的值是一个匹配模式，用于自定义构建结果中的静态资源名称，或者值为一个函数，对每个资源调用以返回匹配模式。这种模式支持以下的占位符：

• [extname] ：包含点的静态资源文件扩展名，例如 .css 。
• [ext] ：不包含点的文件扩展名，例如 css 。
• [hash] ：基于静态资源内容的哈希。也可以通过例如 [hash:10] 设置一个特定的哈希值长度。默认情况下，它会生成一个 base-64 的哈希值。如果你需要减少字符集的大小，可以查看 output.hashCharacters 。
• [name] ：静态资源的名称，不包含扩展名。

正斜杠 / 可以用来划分文件到子目录。当值为函数时， PreRenderedAsset 是 generateBundle 中 OutputAsset 类型的简化版本，它没有 fileName 。另见 output.chunkFileNames ， output.entryFileNames 。

output.banner/output.footer ​

查看 renderChunk 钩子以了解 RenderedChunk 类型。

该选项用于在 bundle 前或后添加一个字符串。其值也可以是一个返回 string 的 Promise 异步函数（注意： banner 和 footer 选项不会破坏 sourcemaps）。

如果该选项值为函数，那么 chunk 就会包含一些额外的信息，通过 RenderedChunk 类型来表示，它是 generateBundle 钩子中使用的 OutputChunk 类型的简化版本，具有以下区别：

• code 和 map 没有设置，因为该 chunk 还没有被渲染。
• 所有包含哈希值的引用 chunk 文件名将包含哈希占位符。包括 fileName 、 imports 、 importedBindings 、 dynamicImports 和 implicitlyLoadedBefore 。当你在该选项返回的代码中使用这样的占位符文件名或部分文件名时，Rollup 将在 generateBundle 之前用实际的哈希值替换掉占位符，确保哈希值反映的是最终生成的 chunk 中的实际内容，包括所有引用的文件哈希值。

chunk 是可变的，在这个钩子中应用的变化将传递到其他插件和生成的 bundle 中。这意味着如果你在这个钩子中增加或删除引入或导出，你应该更新 imports 、 importedBindings 以及 exports 。

// rollup.config.js
export default {
	// ...
	
output





    
: {
		// ...
		
banner
: '/* my-library version ' + version + ' */',
		
footer
: '/* follow me on Twitter! @rich_harris */'
};

另见 output.intro/output.outro 。

output.chunkFileNames ​

interface PreRenderedChunk {
	exports: string[];
	facadeModuleId: string | null;
	isDynamicEntry: boolean;
	isEntry: boolean;
	isImplicitEntry: boolean;
	moduleIds: string[];
	name: string;
	type: 'chunk';
}

该选项用于对代码分割中产生的 chunk 自定义命名，其值也可以是一个函数，对每个 chunk 调用以返回匹配模式。这种模式支持以下的占位符：

• [format] ：输出（output）选项中定义的格式（format），例如 es 或 cjs 。
• [hash] ：仅基于最终生成的 chunk 内容的哈希值，其中包括 renderChunk 中的转换部分和其依赖文件哈希值。你也可以通过例如 [hash:10] 设置一个特定的哈希值长度。默认情况下，它会生成一个 base-64 的哈希值。如果你需要减少字符集的大小，可以查看 output.hashCharacters 。
• [name] ：chunk 的名称。它可以通过 output.manualChunks 选项显示的设置，或者通过插件调用 this.emitFile 设置。否则，它将会根据 chunk 的内容确定。

正斜杠 / 可以用来划分文件到子目录。当值为函数时， PreRenderedChunk 就是 generateBundle 中 OutputChunk 类型的简化版本，它没有依赖于文件名的属性，也没有关于所渲染模块的信息，因为渲染只会在文件名生成之后进行。然而，你还是可以访问到 moduleIds 列表。另见 output.assetFileNames ， output.entryFileNames 。

output.compact ​

该选项用于压缩 Rollup 产生的额外代码。请注意，这个选项不会影响用户的代码。这个选项在构建已经压缩好的代码时是很有用的。

output.dynamicImportInCjs ​

虽然 CommonJS 输出最初只支持 require(…) 语法来引入依赖，但最近的 Node 版本也开始支持 import(…) 语法，这是从 CommonJS 文件中引入 ES 模块的唯一方法。如果这个选项默认值为 true ，表示 Rollup 会在 CommonJS 输出中保持外部依赖以 import(…) 表达式动态引入。将值设置为 false ，以使用 require(…) 语法重写动态引入。

// 输入
import('external').
then





    
(
console
.
log
);
// 设置 dynamicImportInCjs 为 true 或不设置的 cjs 输出
import('external').
then
(
console
.
log
);
// 设置 dynamicImportInCjs 为 false 的 cjs 输出
function 
_interopNamespaceDefault
(
e
) {
	var 
n
 = 
Object
.
create
(null);
	if (
e
) {
		
Object
.
keys
(
e
).
forEach
(function (
k
) {
			if (
k
 !== 'default') {
				var 
d
 = 
Object





    
.
getOwnPropertyDescriptor
(
e
, 
k
);
				
Object
.
defineProperty
(
					
d
.
get

								
enumerable
: true,
								
get
: function () {
									return 
e
[
k
];
	
n
.default = 
e
;
	return 
Object
.
freeze
(
n
);
Promise
.
resolve
()
	.
then
(function () {
		return /*#__PURE__*/ 
_interopNamespaceDefault





    
(
require
('external'));
	.
then
(
console
.
log
);

output.entryFileNames ​

查看 output.chunkFileNames 以了解 PreRenderedChunk 类型。

该选项用于指定 chunks 的入口文件模式，其值也可以是一个函数，对每个入口 chunk 调用以返回匹配模式。这种模式支持以下的占位符：

• [format] ：输出（output）选项中定义的格式（format），例如 es 或 cjs 。
• [hash] ：仅基于最终生成的入口 chunk 内容的哈希值，其中包括 renderChunk 中的转换部分和其依赖文件哈希值。你也可以通过例如 [hash:10] 设置一个特定的哈希值长度。默认情况下，它会生成一个 base-64 的哈希值。如果你需要减少字符集的大小，可以查看 output.hashCharacters 。
• [name] ：入口文件的文件名（不包含扩展名），除非当入口文件为对象时，才用来定义不同的名称。

正斜杠 / 可以用来划分文件到子目录。当值为函数时， PreRenderedChunk 就是 generateBundle 中 OutputChunk 类型的简化版本，它没有依赖于文件名的属性，也没有关于所渲染模块的信息，因为渲染只会在文件名生成之后进行。然而，你还是可以访问到 moduleIds 列表。另见 output.assetFileNames ， output.chunkFileNames 。

在设置 output.preserveModules 选项时，该模式也会生效。需要注意在这种情况下， [name] 将包括来自输出根路径的相对路径以及可能有原始文件的扩展名，如果它不是 .js 、 .jsx 、 .mjs 、 .cjs 、 .ts 、 .tsx 、 .mts 或 .cts 的其中之一。

output.extend ​

该选项用于指定是否扩展 umd 或 iife 格式中 name 选项定义的全局变量。当值为 true 时，该全局变量将定义为 (global.name = global.name || {}) 。当值为 false 时， name 选项指定的全局变量将被覆盖为 (global.name = {}) 。

output.externalImportAttributes ​

是否在输出中为外部引入添加导入属性，如果输出格式为 es 。默认情况下，属性来自输入文件，但插件可以稍后添加或删除属性。例如， import "foo" assert {type: "json"} 将导致相同的导入出现在输出中，除非将该选项设置为 false 。请注意，模块的所有导入都需要具有一致的属性，否则会发出警告。

output.generatedCode ​

该选项用于制定 Rollup 可以在生成的代码中安全地使用哪些语言特性。这不会转译任何用户的代码，而只改变 Rollup 在包装器和辅助函数中使用的代码。你可以从几个预设中选择一个：

• "es5" ：不能使用 ES2015+ 的特性，比如箭头函数，不能使用引号包裹的预留词汇作为属性名。
• "es2015" ：使用任意 ES2015 之前的 JavaScript 特性。

output.generatedCode.arrowFunctions ​

该选项表示是否为自动生成的代码片段使用箭头函数。请注意，在某些地方，比如模块封装器，Rollup 会继续生成用小括号封装的常规函数，因为在一些 JavaScript 引擎中，这些函数会提供 明显更好的性能 。

output.generatedCode.constBindings ​

该选项表示在某些地方和辅助函数中使用 const 而不是 var 。由于代码块的作用域，会使 Rollup 产生更有效的辅助函数。

// 输入
export * from 'external';
// 设置 constBindings 为 false 的 cjs 输出
var 
external





    
 = 
require
('external');
Object
.
keys
(
external
).
forEach
(function (
k
) {
	if (
k
 !== 'default' && !
Object
.
prototype
.
hasOwnProperty
.
call
(
exports
, 
k
))
		
Object
.
defineProperty
(
exports
, 
k





    
, {
			
enumerable
: true,
			
get
: function () {
				return 
external
[
k
];
// 设置 constBindings 为 true 的 cjs 输出
const 
external
 = 
require
('external');
for (const 
k
 in 
external
) {
	if (
k
 !== 'default' && !
Object
.
prototype
.
hasOwnProperty
.
call
(
exports
, 
k
))
		
Object
.
defineProperty
(
exports
, 
k
, {
			
enumerable





    
: true,
			
get
: () => 
external
[
k
]
}

output.generatedCode.objectShorthand ​

该选项表示当属性名称与值匹配时，是否允许在对象中使用别名。

// input
const 
foo
 = 1;
export { 
foo
, 
foo
 as 
bar
 };
// 设置 objectShorthand 为 false 的系统输出
System.register('bundle', [], function (
exports
) {
	'use strict';
	return {
		
execute
: function () {
			const 
foo
 = 1;
			
exports
({ 
foo





    
: 
foo
, 
bar
: 
foo
 });
// 设置 objectShorthand 为 true 的系统输出
System.register('bundle', [], function (
exports
) {
	'use strict';
	return {
		
execute
: function () {
			const 
foo
 = 1;
			
exports
({ 
foo
, 
bar
: 
foo
 });
});

output.generatedCode.preset ​

该选项可以选择上面列出的预设之一，同时覆盖一些选项。

export default {
	// ...
	
output
: {
		
generatedCode
: {
			
preset
: 'es2015',
			
arrowFunctions





    
: false
		// ...
};

output.generatedCode.reservedNamesAsProps ​

该选项确定像 default 这样的预留词，是否可以在不加引号的情况下作为属性名。这将使生成的代码语法符合 ES3 标准。但是请注意，为了完全符合 ES3 标准，你可能还需要对一些内置函数进行补丁（polyfill），比如 Object.keys 或 Array.prototype.forEach 。

// 输入
const foo = null;
export { foo as void };
// 设置 reservedNamesAsProps 为 false 的 cjs 输出
const foo = null;
exports['void'] = foo;
// 设置 reservedNamesAsProps 为 true 的 cjs 输出
const foo = null;
exports.void = foo;

output.generatedCode.symbols ​

该选项确定是否允许在自动生成的代码片断中使用 Symbol 。目前，该选项只控制命名空间是否将 Symbol.toStringTag 属性设置为正确的 Module 值，这意味着对于一个命名空间来说， String(namespace) 打印为 [object Module] 。该值又被用于某些库和框架的特征检测。

// 输入
export const foo = 42;
// 设置 symbols 为 false 的 cjs 输出
const foo = 42;
exports.foo = foo;
// 设置 symbols 为 true 的 cjs 输出
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const foo = 42;
exports.foo = foo;

output.hashCharacters ​

这个选项决定了 Rollup 在生成文件哈希时可以使用的字符集。

• 默认的 "base64" 选项会使用包含 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_ 这些 url 安全的字符串 base-64 哈希。
• "base36" 选项只会使用小写字母和数字 abcdefghijklmnopqrstuvwxyz0123456789 。
• "hex" 选项会生成包含 abcdef0123456789 这些字符的十六进制哈希。

output.hoistTransitiveImports ​

默认情况下，创建多个 chunk 时，入口 chunk 的可传递引入将以空引入的形式被打包。详细信息和背景请查看 "Why do additional imports turn up in my entry chunks when code-splitting?" 。该选项的值为 false 将禁用此行为。当使用 output.preserveModules 选项时，该选项会被忽略，使得永远不会取消引入。

output.importAttributesKey ​

该选项决定 Rollup 用于导入属性的关键词集合。

output.inlineDynamicImports ​

该选项用于内联动态引入，而不是用于创建包含新 chunk 的独立 bundle。该选项只在单一输入源时发挥作用。请注意，它会影响执行顺序：如果该模块是内联动态引入，那么它将会被立即执行。

output.interop ​

该选项用于控制 Rollup 如何处理默认值，命名空间和动态引入像 CommonJS 这样并不支持这些概念的外部依赖格式。请注意，"default" 的默认模式是模仿 NodeJS 的行为，与 TypeScript 的 esModuleInterop 不同。要获得像 TypeScript 中的行为，需要明确地设置该值为 "auto" 。在例子中，我们将使用 CommonJS 格式，但该互操作（interop）的选择也同样适用于 AMD、IIFE 和 UMD 目标。

为了理解不同的取值，我们假设打包以下代码为 cjs ：

import ext_default, * as external from 'external1';
console.log(ext_default, external.bar, external);
import('external2').then(console.log);

请记住，对于 Rollup 来说， import * as ext_namespace from 'external'; console.log(ext_namespace.bar); 完全等同于 import {bar} from 'external'; console.log(bar); ，并且会打包出同样的代码。然而，在上面的例子中，命名空间对象本身也被传递给一个全局函数，这意味着我们需要它组成一个正确的对象。

• "default" 意为所需的值应该被视为引入模块的默认出口，就像在 NodeJS 中从 ES 模块上下文引入 CommonJS 一样。其也支持命名的引入，它们被视为默认引入的属性。为了创建命名空间对象，Rollup 注入了这些辅助函数：

  js

  var 
  external
   = 
  require
  ('external1');
  function 
  _interopNamespaceDefault
  (
  e
  ) {
  	var 
  n
   = 
  Object
  
  
  
  
  
      
  .
  create
  (null);
  	if (
  e
  ) {
  		
  Object
  .
  keys
  (
  e
  ).
  forEach
  (function (
  k
  ) {
  			if (
  k
   !== 'default') {
  				var 
  d
   = 
  Object
  .
  getOwnPropertyDescriptor
  (
  e
  , 
  k
  );
  				
  Object
  .
  defineProperty
  (
  					
  d
  .
  get
  
  								
  enumerable
  : true,
  								
  get
  : function () {
  									return 
  e
  
  
  
  
  
      
  [
  k
  ];
  	
  n
  .default = 
  e
  ;
  	return 
  Object
  .
  freeze
  (
  n
  );
  var 
  external__namespace
   =
  	/*#__PURE__*/ 
  _interopNamespaceDefault
  (
  external
  );
  console
  .
  log
  (
  external
  , 
  external__namespace
  .bar, 
  external__namespace
  );
  Promise
  .
  resolve
  ()
  	.
  then
  (function () {
  		return /*#__PURE__*/ 
  _interopNamespaceDefault
  (
  require
  ('external2'));
  	.
  then
  (
  console
  
  
  
  
  
      
  .
  log
  );

• "esModule" 意为 ES 模块转译为所需模块，其中所需的值对应模块的命名空间，而默认的导出是导出对象的 .default 属性。这是唯一不会注入任何辅助函数的互操作类型：

  js

  var external = require('external1');
  console.log(external.default, external.bar, external);
  Promise.resolve()
  	.then(function () {
  		return require('external2');
  	.then(console.log);

  当使用 esModule 时，Rollup 不添加额外的辅助函数，并且对默认出口也支持实时绑定。

• "auto" 结合了 "esModule" 和 "default" ，通过注入辅助函数，其包含在运行时检测所需的值是否包含 __esModule 属性 的代码。添加这个属性是 TypeScript esModuleInterop 、Babel 和其他工具实现的一种解决方式，标志着所需值是 ES 模块编译后的命名空间：

  js

  var 
  external
   = 
  require
  ('external1');
  function 
  _interopNamespace
  (
  e
  ) {
  	if (
  e
   && 
  e
  
  
  
  
  
      
  .__esModule) return 
  e
  ;
  	var 
  n
   = 
  Object
  .
  create
  (null);
  	if (
  e
  ) {
  		
  Object
  .
  keys
  (
  e
  ).
  forEach
  (function (
  k
  ) {
  			if (
  k
   !== 'default') {
  				var 
  d
   = 
  Object
  .
  getOwnPropertyDescriptor
  (
  e
  , 
  k
  );
  				
  Object
  .
  defineProperty
  (
  					
  d
  .
  get
  
  
  
  
  
      
  
  								
  enumerable
  : true,
  								
  get
  : function () {
  									return 
  e
  [
  k
  ];
  	
  n
  .default = 
  e
  ;
  	return 
  Object
  .
  freeze
  (
  n
  );
  var 
  external__namespace
   = /*#__PURE__*/ 
  _interopNamespace
  (
  external
  );
  console
  .
  log
  (
  	
  external__namespace
  .default,
  	
  external__namespace
  .bar,
  	
  external__namespace
  
  Promise
  .
  resolve
  ()
  	.
  then
  (function () {
  		return /*#__PURE__*/ 
  _interopNamespace
  (
  require
  ('external2'));
  	.
  then
  (
  console