输出

顶级输出key包含一组选项，用于指示webpack如何以及在何处输出捆绑包、资产以及使用webpack捆绑或加载的任何其他内容。

output.assetModule文件名

string='[哈希][文本][查询]' function（pathData，assetInfo）=>字符串

一样输出.filename但为了资产模块.

[姓名],[文件],[查询],[片段],[基础]、和[路径]对于从数据URI替换构建的资产，设置为空字符串。

output.asyncChunks输出同步块

布尔值=true

创建按需加载的异步块。

webpack.config.js

模块.出口= {
  //...输出: {
    //...异步块: 真的,
  },
};

输出辅助注释

一串 对象

与一起使用时输出库和输出库目标，此选项允许用户在导出包装器中插入注释。为每个插入相同的注释库目标类型，集辅助注释转换为字符串：

webpack.config.js

模块.出口= {
  //...输出: {图书馆: “someLibName”,库目标: “嗯”,文件名: 'someLibName.js',辅助注释: '测试注释',
  },
};

这将产生以下结果：

someLibName.js

(功能 webpack通用模块定义(根,工厂) {
  //测试注释
  如果 (类型出口=== '对象' && 类型模块=== '对象')模块.出口= 工厂(要求(“lodash”));
  //测试注释
  其他的 如果 (类型定义=== '功能' &&定义.amd公司)
    定义([“lodash”],工厂);
  //测试注释
  其他的 如果 (类型出口=== '对象')出口[“someLibName”] = 工厂(要求(“lodash”));
  //测试注释
  其他的根[“someLibName”] = 工厂(根['_']);
})(这, 功能 (__网络包_EXTERNAL_MODULE_1__) {
  // ...
});

用于对每个库目标注释，传递对象：

webpack.config.js

模块.出口= {
  //...输出: {
    //...辅助注释: {根: '根注释',公共设施: “CommonJS注释”,通用js2: “CommonJS2注释”,amd公司: “AMD评论”,
    },
  },
};

输出.字符集

布尔值=true

告诉webpack添加charset=“utf-8”到HTML<脚本>标签。

output.chunk文件名

字符串=“[id].js” function（pathData，assetInfo）=>字符串

此选项确定非初始化区块文件的名称。请参见输出.filename选项获取有关可能值的详细信息。

请注意，这些文件名需要在运行时生成，以发送对块的请求。因此，占位符[姓名]和[春喀什语]需要使用webpack运行时将块id到占位符值的映射添加到输出包。这会增加大小，并可能在任何块的占位符值更改时使捆绑包无效。

默认情况下[标识].js使用了或从中推断出的值输出.filename([姓名]替换为[标识]或[标识]。已预先添加）。

webpack.config.js

模块.出口= {
  //...输出: {
    //...chunk文件名: “[id].js”,
  },
};

作为函数使用：

webpack.config.js

模块.出口= {
  //...输出: {
    chunk文件名: (路径数据) => {
      返回路径数据.块.名称=== “主要” ? '[name].js' : '[name]/[name].js';
    },
  },
};

output.chunk格式

假 字符串：“array-push”|“commonjs”|“module”|<任何字符串>

块的格式（默认包含的格式为'数组推送'（web/WebWorker），“commonjs”（节点.js），'模块'（ESM），但其他可能通过插件添加）。

webpack.config.js

模块.出口= {
  //...输出: {
    //...chunk格式: “commonjs”,
  },
};

输出chunkLoadTimeout

数量=120000

区块请求过期前的毫秒数。自webpack 2.6.0以来，此选项一直受支持。

webpack.config.js

模块.出口= {
  //...输出: {
    //...chunkLoadTimeout（块加载超时）: 30000,
  },
};

output.chunk加载全局

string='webpackChunkwebpack'

webpack使用全局变量加载块。

webpack.config.js

模块.出口= {
  //...输出: {
    //...chunk加载全局: “myCustomFunc”,
  },
};

output.chunk加载

假 string:“jsonp”|“import-scripts”|“需要”|“async-node”|“导入”|<任何字符串>

加载块的方法（默认情况下包括“jsonp”（网络），'导入'（ESM），'导入脚本'（网络工作者），“需要”（sync node.js），'异步节点'（async node.js），但其他可能由插件添加）。

webpack.config.js

模块.出口= {
  //...输出: {
    //...chunk加载: '异步节点',
  },
};

输出.清洁

5.20.0+

布尔值 {dry？：boolean，keep？：RegExp|string|（（文件名：string）=>boolean）}

模块.出口= {
  //...输出: {清洁的: 真的, //在发出之前清理输出目录。
  },
};

模块.出口= {
  //...输出: {清洁的: {干的: 真的, //记录应该删除的资产，而不是删除它们。
    },
  },
};

模块.出口= {
  //...输出: {清洁的: {保持: /忽略\/dir\//, //将这些资产置于“忽略/目录”下。
    },
  },
};

//或模块.出口= {
  //...输出: {清洁的: {
      保持(资产) {
        返回资产.包括('忽略/dir');
      },
    },
  },
};

您也可以将其与挂钩一起使用：

网络包.清洁插件.获取编译挂钩(汇编).保持.水龙头(
  “测试”,
  (资产) => {
    如果 (/忽略\/dir\//.测试(资产)) 返回 真的;
  }
);

输出.compareBeforeEmit

布尔值=true

告诉webpack在写入输出文件系统之前，检查待发出文件是否已经存在并具有相同的内容。

模块.出口= {
  //...输出: {发射前比较: 假,
  },
};

输出交叉原始加载

布尔值=false string:“anonymous”|“use-credentials”

告诉webpack启用交叉原点加载块。仅当目标设置为“网络”，它使用JSONP通过添加脚本标记来加载按需块。

• “匿名”-启用交叉原点加载没有凭据
• '使用凭据'-启用交叉原点加载具有凭据

output.cssChunk文件名

一串 function（pathData，assetInfo）=>字符串

此选项确定磁盘上非初始化CSS输出文件的名称。请参见输出.filename选项获取有关可能值的详细信息。

你不能在此处指定绝对路径。但是，您可以随意包括由以下内容分隔的文件夹'/'。此指定路径与输出路径值来精确定位磁盘上的位置。

output.css文件名

一串 function（pathData，assetInfo）=>字符串

此选项确定磁盘上CSS输出文件的名称。请参见输出.filename选项获取有关可能值的详细信息。

你不能在此处指定一个绝对路径。但是，您可以随意包括由以下内容分隔的文件夹'/'。此指定路径与输出路径值来精确定位磁盘上的位置。

输出.cssHeadDataCompression

5.91.0+

布尔值

此选项决定是否压缩CSS文件的head标记中生成的元数据。此选项默认为真的在里面生产和假在里面发展 模式分别是。

输出.devtoolFallback模块文件名模板

一串 功能（信息）

当上述模板字符串或函数产生重复项时，将使用回退。

请参见输出.devtoolModule文件名模板.

输出.devtoolModule文件名模板

string='webpack://[namespace]/[resource-path]？[装载机]' 函数（信息）=>字符串

此选项仅在以下情况下使用开发工具使用需要模块名称的选项。

自定义每个源映射中使用的名称来源数组。这可以通过传递模板字符串或函数来完成。例如，当使用devtool:“eval”.

webpack.config.js

模块.出口= {
  //...输出: {开发工具模块文件名模板:
      'webpack://[namespace]/[resource-path]？[装载机]',
  },
};

以下替换在模板字符串中可用（通过webpack的内部模块文件名助手):

模板	说明
[绝对资源路径]	绝对文件名
[所有装载机]	自动显式加载程序和参数，直到第一个加载程序的名称
[散列]	模块标识符的哈希
[标识]	模块标识符
[装载机]	显式装入器和参数，直到第一个装入器的名称
[资源]	用于解析文件的路径和第一个加载程序上使用的任何查询参数
[资源路径]	用于解析没有任何查询参数的文件的路径
[名称空间]	模块命名空间。这通常是作为库构建时的库名称，否则为空

使用功能时，可以通过信息参数：

模块.出口= {
  //...输出: {
    开发工具模块文件名模板: (信息) => {
      返回 `网络包：///${信息.资源路径}?${信息.装载机}`;
    },
  },
};

如果多个模块会产生相同的名称，输出.devtoolFallback模块文件名模板而是用于这些模块。

输出.devtoolNamespace

一串

此选项确定与输出.devtoolModule文件名模板。如果未指定，则默认值为：输出唯一名称。它用于在加载使用webpack构建的多个库时，防止源映射中的源文件路径冲突。

例如，如果您有两个库，其中包含名称空间图书馆1和图书馆2，两者都有一个文件./src/index.js（内容可能不同），它们将这些文件公开为webpack://library1/./src/index.js和webpack://library2/./src/index.js.

output.enabled区块加载类型

[string:'jsonp'|'导入脚本'|'需要'|'异步节点'|<任何字符串>]

允许入口点使用的块加载类型列表。将由webpack自动填充。仅当使用函数作为输入选项并从那里返回chunkLoading选项时才需要。

webpack.config.js

模块.出口= {
  //...输出: {
    //...启用区块加载类型: [“jsonp”, “需要”],
  },
};

输出启用的库类型

[字符串]

允许入口点使用的库类型列表。

模块.出口= {
  //...输出: {启用的库类型: ['模块'],
  },
};

output.enabled Wasm加载类型

[字符串]

为入口点启用的wasm加载类型列表。

模块.出口= {
  //...输出: {启用Wasm加载类型: [“获取”],
  },
};

输出.环境

告诉webpack在生成的运行时代码中可以使用哪种ES-功能。

模块.出口= {输出: {环境: {
      //环境支持箭头函数（'（）=>{…}'）。箭头函数: 真的,
      //该环境支持异步函数和等待（'async function（）{await…}'）。异步函数: 真的,
      //环境支持BigInt作为文本（123n）。大IntLiteral: 假,
      //环境支持变量声明的const和let。
      常量: 真的,
      //环境支持破坏（“{a，b}=obj”）。破坏: 真的,
      //该环境支持异步import（）函数来导入EcmaScript模块。动态导入: 假,
      //该环境在创建辅助进程时支持异步导入（），目前仅支持web目标。动态导入Worker: 假,
      //环境支持“for of”迭代（“for（const x of array）{…}”）。forOf（属于）: 真的,
      //环境支持“globalThis”。全球This: 真的,
      //该环境支持ECMAScript Module语法来导入ECMAScript模块（从“…”导入…）。模块: 假,
      //确定是否在支持node:前缀的环境中为核心模块导入生成该前缀。
      //这仅适用于Webpack运行时代码。核心模块的节点Prefix: 假,
      //环境支持可选的链接（“obj？.a”或“obj？.（）”）。可选链: 真的,
      //环境支持模板文本。模板文字: 真的,
    },
  },
};

输出.filename

一串 function（pathData，assetInfo）=>字符串

此选项确定每个输出捆绑包的名称。包被写入输出路径选项。

对于单个进入点，这可以是一个静态名称。

webpack.config.js

模块.出口= {
  //...输出: {文件名: “bundle.js”,
  },
};

然而，当通过多个入口点、代码分割或各种插件创建多个bundle时，您应该使用以下替换之一为每个bundle指定一个唯一的名称。。。

使用条目名称：

webpack.config.js

模块.出口= {
  //...输出: {文件名: '[name].bundle.js',
  },
};

使用内部块id：

webpack.config.js

模块.出口= {
  //...输出: {文件名: “[id].bundle.js”,
  },
};

使用从生成的内容生成的哈希：

webpack.config.js

模块.出口= {
  //...输出: {文件名: “[contenthash].bundle.js”,
  },
};

组合多个替换：

webpack.config.js

模块.出口= {
  //...输出: {文件名: “[姓名]。[contenthash].bundle.js',
  },
};

使用函数返回文件名：

webpack.config.js

模块.出口= {
  //...输出: {
    文件名: (路径数据) => {
      返回路径数据.块.名称=== “主要” ? '[name].js' : '[name]/[name].js';
    },
  },
};

确保阅读缓存指南了解详细信息。所涉及的步骤不仅仅是设置此选项。

请注意，此选项称为文件名，但您仍可以使用类似的选项'js/[name]/bundle.js'创建文件夹结构。

请注意，此选项不会影响按需加载块的输出文件。它只影响最初加载的输出文件。对于按需加载的区块文件output.chunk文件名选项。由加载程序创建的文件也不受影响。在这种情况下，您必须尝试特定加载器的可用选项。

模板字符串

以下替换在模板字符串中可用（通过webpack的内部模板路径插件):

编译级可用的替换：

模板	说明
[完整散列]	编译的完整哈希
[散列]	相同，但已弃用

Chunk级别可用的替换：

模板	说明
[标识]	块的ID
[姓名]	块的名称（如果设置），否则为块的ID
[春喀什语]	块的散列，包括块的所有元素
[内容哈希]	块的散列，仅包括此内容类型的元素（受优化.realContentHash)

模块级可用替代品：

模板	说明
[标识]	模块的ID
[模块化]	相同，但已弃用
[散列]	模块的哈希
[模数]	相同，但已弃用
[内容哈希]	模块内容的散列

文件级可用的替换：

模板	说明
[文件]	文件名和路径，无查询或片段
[查询]	带前导的查询?
[片段]	带前导的片段#
[基础]	仅文件名（包括扩展名），不带路径
[文件库]	相同，但已弃用
[路径]	只有路径，没有文件名
[姓名]	只有不带扩展名或路径的文件名
[分机]	带前导的扩展.（不适用于输出.filename)

URL级别上可用的替换：

模板	说明
[网址]	统一资源定位地址

散列的长度([散列],[内容哈希]或[春喀什语])可以使用指定[散列：16]（默认为20）。或者，指定output.hashDigestLength（输出哈希摘要长度）全局配置长度。

当您想在实际文件名中使用其中一个占位符时，可以筛选出占位符替换。例如，要输出文件[名称].js，你必须逃离[姓名]通过在括号之间添加反斜杠来占位符。以便[\名称\]生成[姓名]而不是被替换为名称资产。

例子：[\id\]生成[标识]而不是被替换为身份证件.

如果将函数用于此选项，则将向该函数传递一个包含上表中替换数据的对象。替换也将应用于返回的字符串。传递的对象将具有以下类型：（根据上下文可用的属性）

类型 路径数据 = {搞砸: 一串;
  哈希长度: (数) => 一串;块:块|ChunkPathData（ChunkPath数据）;
  模块:模块|模块路径数据;内容哈希类型: 一串;contentHash: 一串;
  包含长度的内容哈希: (数) => 一串;文件名: 一串;网址: 一串;运行时: 一串 |可排序集合<一串>;chunk图形:ChunkGraph（区块图）;
};
类型 ChunkPathData（ChunkPath数据） = {身份证件: 一串 | 数;名称: 一串;搞砸: 一串;
  哈希长度: (数) => 一串;contentHash:记录<一串, 一串>;包含长度的内容哈希:记录<一串, (数) => 一串>;
};
类型 模块路径数据 = {身份证件: 一串 | 数;搞砸: 一串;
  哈希长度: (数) => 一串;
};

output.global对象

string='self'

瞄准库时，尤其是当库.类型是“嗯”，此选项指示将使用哪个全局对象装入库。要使UMD构建在浏览器和Node.js上都可用，请设置output.global对象选择“这个”。默认为自己用于类似Web的目标。

入口点的返回值将使用输出库名称。取决于类型选项，全局对象可以分别更改，例如。，自己,全球的，或全局此.

例如：

webpack.config.js

模块.出口= {
  // ...输出: {图书馆: {名称: “myLib”,类型: “嗯”,
    },文件名: “myLib.js”,全局对象: “这个”,
  },
};

output.hashDigest（输出哈希摘要）

string=“十六进制”

生成哈希时要使用的编码。来自Node的所有编码。JS’哈希.digest支持。使用“base64”for文件名可能有问题，因为它具有字符/在字母表中。同样地“拉丁语1”可以包含任何字符。

output.hashDigestLength（输出哈希摘要长度）

数字=20

要使用的哈希摘要的前缀长度。

output.hash函数

字符串=“md4” 功能

要使用的哈希算法。Node的所有功能。JS’加密.创建哈希支持。自4.0.0α2，的hashFunction（哈希函数）现在可以是自定义哈希函数的构造函数。出于性能原因，可以提供非加密哈希函数。

模块.出口= {
  //...输出: {hashFunction（哈希函数）: 要求(“metrohash”).MetroHash64,
  },
};

确保哈希函数将具有更新和消化方法可用。

output.hashSalt输出哈希盐

通过Node更新散列的可选salt。JS’哈希更新.

output.hotUpdateChunk文件名

字符串='[id]。[fullhash].hotupdate.js'

自定义热更新块的文件名。请参见输出.filename选项获取有关可能值的详细信息。

此处只允许使用以下占位符[标识]和[完整哈希]，默认值为：

webpack.config.js

模块.出口= {
  //...输出: {hotUpdateChunk文件名: '[id]。[fullhash].hotupdate.js',
  },
};

output.hotUpdate全局

一串

仅在以下情况下使用目标设置为“网络”，它使用JSONP来加载热更新。

JSONP函数用于异步加载热更新块。

有关详细信息，请参阅output.chunk加载全局.

output.hotUpdateMain文件名

string='[运行时]。[fullhash].hotupdate.json’ 功能

自定义主热更新文件名。[完整散列]和[运行时]可用作占位符。

输出.ife

布尔值=true

告诉webpack添加IIFE公司封装发出的代码。

模块.出口= {
  //...输出: {生活: 真的,
  },
};

output.ignoreBrowser警告

5.81.0+

布尔值=false

在生产中隐藏浏览器控制台中的警告。此选项不影响终端/控制台输出。

webpack.config.js

模块.出口= {
  //...输出: {ignoreBrowser警告: 真的,
  },
};

output.import函数名称

string=“导入”

本地人的姓名导入（）功能。可用于聚合填充，例如dynamic-import-polyfill公司.

webpack.config.js

模块.出口= {
  //...输出: {导入功能名称: “__import__”,
  },
};

输出导入元名称

一串

本地人的姓名进口.meta对象（可以交换为polyfill）。

webpack.config.js

模块.出口= {
  //...输出: {导入元名称: 'pseudoImport.meta',
  },
};

输出库

输出一个公开入口点导出的库。

• 类型：string|string[]|对象

让我们看一个例子。

webpack.config.js

模块.出口= {
  // …进入: './src/index.js',输出: {图书馆: “MyLibrary”,
  },
};

假设您已导出源代码/索引.js条目：

出口 功能 你好(名称) {慰问.日志(`你好${名称}`);
}

现在，变量我的图书馆将与条目文件的导出绑定，下面介绍如何使用webpack捆绑库：

<脚本 型钢混凝土="https://example.org/path/to/my-library.js"></脚本>
<脚本>我的图书馆.你好('网络包');
</脚本>

在上面的示例中，我们将单个条目文件传递给进入然而，webpack可以接受多种入口点例如阵列，或一个对象.

1. 如果您提供阵列作为进入点，只有数组中的最后一个才会被暴露。

   模块.出口= {
     // …进入: ['./src/a.js', './src/b.js’], //只有b.js格式的导出才会被公开输出: {图书馆: “MyLibrary”,
     },
   };

2. 如果对象作为进入点，可以使用阵列的语法图书馆:

   模块.出口= {
     // …进入: {一: './src/a.js',b条: './src/b.js’,
     },输出: {文件名: '[name].js',图书馆: [“MyLibrary”, '[姓名]'], //name是此处的占位符
     },
   };

   假设两者a.js公司和b.js公司导出函数你好，以下是如何使用库：

   <脚本 型钢混凝土="https://example.org/path/to/a.js"></脚本>
   <脚本 型钢混凝土="https://example.org/path/to/b.js"></脚本>
   <脚本>我的图书馆.一.你好('网络包');我的图书馆.b条.你好('网络包');
   </脚本>

   请参见这个例子了解更多信息。

   请注意，如果要为每个入口点配置库选项，则上述配置将无法按预期工作。下面是如何做到这一点在每个条目下:

   模块.出口= {
     // …进入: {主要的: {
         进口: './src/index.js',图书馆: {
           //“output.library”下的所有选项都可以在此处使用名称: “MyLibrary”,类型: “嗯”,umd名称定义: 真的,
         },
       },另一个: {
         进口: './src/another.js',图书馆: {名称: “另一个库”,类型: “commonjs2”,
         },
       },
     },
   };

输出库.amdContainer

5.78.0+

使用容器（在全局空间中定义）进行调用定义/要求AMD模块中的函数。

模块.出口= {
  // …输出: {图书馆: {amd容器: 'window[“clientContainer”]',类型: “amd”, //或“amd-require”
    },
  },
};

这将导致以下捆绑：

窗口['客户端容器'].定义(/*定义参数*/); //或“amd-require”窗口['clientContainer'].require（/*require args*/）；

输出库名称

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,
    },
  },
};

指定库的名称。

• 类型：

  一串 | 一串[] | {amd公司?: 一串,公共设施?: 一串,根?: 一串 | 一串[]}

输出库类型

配置如何公开库。

• 类型：一串

  默认情况下包括的类型有“var”,'模块',“分配”,'分配属性',“这个”,“窗口”,“自我”,“全局”,“commonjs”,“commonjs2”,“commonjs-module”,“commonjs-static”,“amd”,“amd-require”,“嗯”,“umd2”,'jsonp'和“系统”，但其他可能是通过插件添加的。

对于以下示例，我们将使用_条目_返回_指示入口点返回的值。

公开变量

这些选项将入口点的返回值（例如，无论导出的入口点是什么）分配给输出库名称在任何范围内都包括该捆绑包。

类型：'var'

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: “var”,
    },
  },
};

加载库时入口点的返回值将分配给变量：

无功功率，无功功率我的图书馆=_条目_返回_;

//在加载了“MyLibrary”的单独脚本中…我的图书馆.做点什么();

type:'assign'

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: “分配”,
    },
  },
};

这将生成一个隐含的全局变量，该变量可能会重新分配现有值（请谨慎使用）：

我的图书馆=_条目_返回_;

请注意，如果我的图书馆之前没有定义，您的库将在全局范围内设置。

type:'分配属性'

5.16.0+

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: '分配属性',
    },
  },
};

类似type:'assign'但这是一个更安全的选择，因为它可以重复使用我的图书馆如果它已经存在：

//仅在MyLibrary不存在时创建它我的图书馆= 类型我的图书馆=== '未定义' ? {} :我的图书馆;
//然后将返回值复制到MyLibrary
//与Object.assign类似

//例如，在条目中导出一个“hello”函数，如下所示
出口 功能 你好(名称) {慰问.日志(`你好${名称}`);
}

//在加载了MyLibrary的另一个脚本中
//您可以这样运行“hello”函数我的图书馆.你好(“世界”);

通过对象分配公开

这些选项将入口点的返回值（例如，导出的任何入口点）分配给以下定义的名称下的特定对象输出库名称.

type:“this”

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: “这个”,
    },
  },
};

这个入口点的返回值将分配给这在由命名的属性下输出库名称.的含义这随你：

这[“MyLibrary”] =_条目_返回_;

//在单独的脚本中。。。
这.我的图书馆.做点什么();我的图书馆.做点什么(); //如果“this”是窗口

type:'窗口'

模块.出口= {
  // …输出: {图书馆: {名称: '我的库',类型: '窗口',
    },
  },
};

这个入口点的返回值将分配给窗口对象使用输出库名称值。

窗口[“MyLibrary”] =_条目_返回_;窗口.我的图书馆.做点什么();

type:'全局'

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: “全局”,
    },
  },
};

这个入口点的返回值将使用输出库名称值。取决于目标值，全局对象可以分别更改，例如。，自己,全球的或全球This.

全球的[“MyLibrary”] =_条目_返回_;全球的.我的图书馆.做点什么();

type:'commonjs'

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: “commonjs”,
    },
  },
};

这个输入点的返回值将分配给出口对象使用输出库名称值。顾名思义，这在CommonJS环境中使用。

出口[“MyLibrary”] =_条目_返回_;

要求('我的库').做点什么();

模块定义系统

这些选项将产生一个带有完整头的捆绑包，以确保与各种模块系统兼容。这个输出库名称选项将具有不同的含义，如下所示输出库类型选项。

type:'模块'

模块.出口= {
  // …实验: {输出模块: 真的,
  },输出: {图书馆: {
      //不要在此处指定“名称”类型: '模块',
    },
  },
};

输出ES模块。

然而，此功能仍处于实验阶段，尚未完全支持，因此请确保启用实验输出模块事先。此外，您可以在中跟踪开发进度这个线程.

类型：'commonjs2'

模块.出口= {
  // …输出: {图书馆: {
      //注意这里没有名字类型: “commonjs2”,
    },
  },
};

这个入口点的返回值将分配给模块.导出顾名思义，它用于Node.js（CommonJS）环境：

模块.出口=_条目_返回_;

要求(“MyLibrary”).做点什么();

如果我们指定输出库名称具有类型：commmonjs2，入口点的返回值将分配给模块导出。[output.library.name].

type:'commonjs-static'

5.66.0+

模块.出口= {
  // …输出: {图书馆: {
      //注意这里没有名字类型: “commonjs-static”,
    },
  },
};

单个导出将设置为上的属性模块.导出.名称中的“static”是指可进行静态分析的输出，因此命名导出可通过Node.js导入ESM：

输入：

出口 功能 做点什么() {}

输出：

功能 做点什么() {}

// …出口.做点什么=__Web包导出（_E）__.做点什么;

消耗量（CommonJS）：

常量 {做点什么} = 要求('./output.cjs'); //doSomething=>[函数：doSomethong]

消耗量（ESM）：

进口 {做点什么} 从 './output.cjs'; //doSomething=>[函数：doSomethong]

类型：'amd'

这将使您的库作为AMD模块公开。

AMD模块要求条目块（例如<脚本>标记）用特定属性定义，例如to定义和要求通常由RequireJS或任何兼容的加载程序（如杏仁）提供。否则，直接加载生成的AMD包将导致如下错误未定义define.

使用以下配置。。。

模块.出口= {
  //...输出: {图书馆: {名称: “MyLibrary”,类型: “amd”,
    },
  },
};

将使用名称定义生成的输出“我的图书馆”即：

定义(“MyLibrary”, [], 功能 () {
  返回_条目_返回_;
});

捆绑包可以作为脚本标记的一部分包含，可以这样调用捆绑包：

要求([“MyLibrary”], 功能 (我的图书馆) {
  //对图书馆做点什么。。。
});

如果输出库名称未定义，则生成以下内容。

定义(功能 () {
  返回_条目_返回_;
});

如果直接使用<脚本>标签。它只能通过与RequireJS兼容的异步模块加载器通过该文件的实际路径工作，因此在本例中输出路径和输出.filename如果这些文件直接在服务器上公开，那么对于这个特定的设置可能会变得很重要。

type:'amd-require'

模块.出口= {
  //...输出: {图书馆: {名称: “MyLibrary”,类型: “amd-require”,
    },
  },
};

这会将您的输出打包为立即执行的AMD需要（依赖项，工厂）包装器。

这个“amd-require”类型允许使用AMD依赖项，而不需要单独的稍后调用。与“amd”类型，这取决于适当的要求功能在加载webpack输出的环境中可用。

对于此类型，无法使用库名称。

类型：“umd”

这将在所有模块定义下公开您的库，允许它与CommonJS、AMD一起工作，并作为全局变量。看看UMD存储库了解更多信息。

在这种情况下，您需要图书馆名称属性来命名模块：

模块.出口= {
  //...输出: {图书馆: {名称: “MyLibrary”,类型: 'umd',
    },
  },
};

最后，输出是：

(功能 webpack通用模块定义(根,工厂) {
  如果 (类型出口=== '对象' && 类型模块=== '对象')模块.出口= 工厂();
  其他的 如果 (类型定义=== '功能' &&定义.amd公司) 定义([],工厂);
  其他的 如果 (类型出口=== '对象')出口[“MyLibrary”] = 工厂();
  其他的根[“MyLibrary”] = 工厂();
})(全球的, 功能 () {
  返回_条目_返回_;
});

请注意，省略图书馆名称将导致将入口点返回的所有属性直接分配给根对象，如对象分配部分。示例：

模块.出口= {
  //...输出: {类型: “嗯”,
  },
};

输出将是：

(功能 webpack通用模块定义(根,工厂) {
  如果 (类型出口=== '对象' && 类型模块=== '对象')模块.出口= 工厂();
  其他的 如果 (类型定义=== '功能' &&定义.amd公司) 定义([],工厂);
  其他的 {
    无功功率，无功功率一= 工厂();
    对于 (无功功率，无功功率我在里面一) (类型出口=== '对象' ?出口:根)[我] =一[我];
  }
})(全球的, 功能 () {
  返回_入口回转_;
});

您可以为指定对象图书馆名称对于每个目标的不同名称：

模块.出口= {
  //...输出: {图书馆: {名称: {根: “MyLibrary”,amd公司: “我的名字”,公共设施: “我的普通图书馆”,
      },类型: “嗯”,
    },
  },
};

type:'系统'

这将以系统注册器模块。此功能于年首次发布网络包4.30.0.

系统模块要求全局变量系统执行webpack捆绑包时，浏览器中会显示。正在编译到系统寄存器格式允许您System.import（'/bundle.js'）无需额外配置，并将webpack捆绑包加载到系统模块注册表中。

模块.出口= {
  //...输出: {图书馆: {类型: “系统”,
    },
  },
};

输出：

系统.登记([], 功能 (__WEBPACK_DYNAMIC_EXPORT（网络包_动态_导出）__,__系统上下文__) {
  返回 {
    执行: 功能 () {
      // ...
    },
  };
});

通过添加输出库名称除了具有输出库类型设置为系统，输出捆绑包将库名称作为参数系统注册器:

系统.登记(
  “MyLibrary”,
  [],
  功能 (__WEBPACK_DYNAMIC_EXPORT（网络包_动态_导出）__,__系统上下文__) {
    返回 {
      执行: 功能 () {
        // ...
      },
    };
  }
);

其他类型

类型：'jsonp'

模块.出口= {
  // …输出: {图书馆: {名称: “MyLibrary”,类型: “jsonp”,
    },
  },
};

这将把入口点的返回值包装到jsonp包装器中。

我的图书馆(_条目_返回_);

库的依赖项将由外部配置。

输出.库.导出

指定应公开为库的导出。

• 类型：string|string[]

它是未定义默认情况下，它将导出整个（名称空间）对象。下面的示例演示了使用时此配置的效果output.library.type：'var'.

模块.出口= {输出: {图书馆: {名称: “MyLibrary”,类型: “var”,
      出口: “默认”,
    },
  },
};

入口点的默认导出将指定给库名称：

//如果条目具有默认导出
无功功率，无功功率我的图书馆=_条目_返回_.违约;

您可以将数组传递给输出.库.导出此外，它还将被解释为要分配给库名称的模块的路径：

模块.出口= {输出: {图书馆: {名称: “MyLibrary”,类型: “var”,
      出口: [“默认”, '子模块'],
    },
  },
};

这是图书馆代码：

无功功率，无功功率我的图书馆=_条目_返回_.违约.子模块;

输出库辅助注释

在UMD包装中添加注释。

• 类型：字符串{amd？：string，commonjs？：strin，commonjs2？：字符串，根？：string}

为每个插入相同的注释城市管理局类型，集辅助注释转换为字符串：

模块.出口= {
  // …模式: “开发”,输出: {图书馆: {名称: “MyLibrary”,类型: “嗯”,辅助注释: '测试注释',
    },
  },
};

这将产生以下结果：

(功能 webpack通用模块定义(根,工厂) {
  //测试注释
  如果 (类型出口=== '对象' && 类型模块=== '对象')模块.出口= 工厂();
  //测试注释
  其他的 如果 (类型定义=== '功能' &&定义.amd公司) 定义([],工厂);
  //测试注释
  其他的 如果 (类型出口=== '对象')出口[“MyLibrary”] = 工厂();
  //测试注释
  其他的根[“MyLibrary”] = 工厂();
})(自己, 功能 () {
  返回_条目_返回_;
});

对于细粒度控制，传递对象：

模块.出口= {
  // …模式: “开发”,输出: {图书馆: {名称: “MyLibrary”,类型: “嗯”,辅助注释: {根: '根注释',公共设施: “CommonJS注释”,通用js2: “CommonJS2注释”,amd公司: “AMD评论”,
      },
    },
  },
};

output.library.umdNamed定义

布尔值

使用时输出库类型：“umd”，设置output.library.umdNamed定义到真的将命名UMD构建的AMD模块。否则，匿名定义使用。

模块.出口= {
  //...输出: {图书馆: {名称: “MyLibrary”,类型: “嗯”,umd名称定义: 真的,
    },
  },
};

AMD模块将是：

定义(“MyLibrary”, [],工厂);

输出.库导出

一串 [字符串]

配置将通过库目标。它是未定义默认情况下，如果设置库目标转换为空字符串，例如。''它将导出整个（名称空间）对象。下面的示例演示了使用时此配置的效果libraryTarget:“var”.

支持以下配置：

libraryExport:'默认'-入口点的默认导出将分配给库目标：

//如果条目的默认导出为`MyDefaultModule`
无功功率，无功功率我的默认模块=_条目_返回_.违约;

libraryExport:'我的模块'-指定的模块将分配给库目标：

无功功率，无功功率我的模块=_条目_返回_.我的模块;

libraryExport:['MyModule'，'MySubModule']-数组被解释为模块的路径要分配给库目标：

无功功率，无功功率我的子模块=_条目_返回_.我的模块.我的子模块;

使用库导出上面指定的配置，可以这样使用生成的库：

我的默认模块.做点什么();我的模块.做点什么();我的子模块.做点什么();

输出库目标

字符串=“var”

配置如何公开库。可以使用以下任一选项。请注意，此选项与指定给输出库。对于以下示例，假设输出库配置为我的图书馆.

公开变量

这些选项将入口点的返回值（例如，导出的任何入口点）分配给输出库无论捆绑包包含在什么范围。

libraryTarget:“var”

加载库时入口点的返回值将被分配给一个变量：

无功功率，无功功率我的图书馆=_条目_返回_;

//在单独的脚本中。。。我的图书馆.做点什么();

libraryTarget:'分配'

这将生成一个隐含的全局变量，该变量可能会重新分配现有值（请谨慎使用）：

我的图书馆=_条目_返回_;

请注意，如果我的图书馆之前没有定义，您的库将在全局范围中设置。

libraryTarget:'分配属性'

5.16.0+

将返回值复制到目标对象（如果存在），否则先创建目标对象：

//如果目标对象不存在，则创建它我的图书馆= 类型我的图书馆=== '未定义' ? {} :我的图书馆;
//然后将返回值复制到MyLibrary
//与Object.assign类似

//例如，在条目中导出一个“hello”函数，如下所示
出口 功能 你好(名称) {慰问.日志(`你好${名称}`);
}

//在另一个运行MyLibrary的脚本中
//您可以这样运行“hello”函数我的图书馆.你好(“世界”);

通过对象分配公开

这些选项将入口点的返回值（例如，导出的任何入口点）分配给以下定义的名称下的特定对象输出库.

如果输出库未分配非空字符串，则默认行为是，入口点返回的所有属性都将按照为特定输出库目标，通过以下代码片段：

(功能 (电子,一) {
  对于 (无功功率，无功功率我在里面一) {电子[我] =一[我];
  }
})(输出.库目标,_入口回转_);

libraryTarget:“此”

这个入口点的返回值将在名为的属性下分配给此输出库.的含义这随你：

这[“MyLibrary”] =_条目_返回_;

//在单独的脚本中。。。
这.我的图书馆.做点什么();我的图书馆.做点什么(); //如果这是窗户

libraryTarget:'窗口'

这个入口点的返回值将分配给窗口对象使用输出库值。

窗口['我的库'] =_条目_返回_;窗口.我的图书馆.做点什么();

libraryTarget:“全局”

这个入口点的返回值将分配给全球的对象使用输出库值。

全球的[“MyLibrary”] =_入口回转_;全球的.我的图书馆.做点什么();

libraryTarget:'commonjs'

这个入口点的返回值将分配给出口对象使用输出库值。顾名思义，这在CommonJS环境中使用。

出口[“MyLibrary”] =_条目_返回_;

要求(“MyLibrary”).做点什么();

模块定义系统

这些选项将产生一个带有完整头的捆绑包，以确保与各种模块系统兼容。这个输出库选项将具有不同的含义，如下所示输出库目标选项。

libraryTarget:'模块'

输出ES模块。确保启用实验输出模块事先。

请注意，此功能尚未完全支持，请在中跟踪进度这个线程.

libraryTarget:“commonjs2”

这个入口点的返回值将分配给模块.导出。顾名思义，这在CommonJS环境中使用：

模块.出口=_条目_返回_;

要求(“MyLibrary”).做点什么();

请注意输出库不能用于此特定输出库目标，有关详细信息，请阅读此问题.

库目标：“amd”

这将把你的库暴露为AMD模块。

AMD模块要求条目块（例如<脚本>标记）用特定属性定义，例如to定义和要求通常由RequireJS或任何兼容的加载程序（如杏仁）提供。否则，直接加载生成的AMD包将导致如下错误未定义define.

使用以下配置。。。

模块.出口= {
  //...输出: {图书馆: “MyLibrary”,库目标: “amd”,
  },
};

生成的输出将定义为“MyLibrary”，即。

定义(“MyLibrary”, [], 功能 () {
  返回_条目_返回_;
});

捆绑包可以作为脚本标记的一部分包含，可以这样调用捆绑包：

要求([“MyLibrary”], 功能 (我的图书馆) {
  //对图书馆做点什么。。。
});

如果输出库未定义，则生成以下内容。

定义([], 功能 () {
  返回_条目_返回_;
});

如果直接使用<脚本>标签。它只能通过与RequireJS兼容的异步模块加载器通过该文件的实际路径工作，因此在本例中输出路径和输出.filename如果这些文件直接在服务器上公开，那么对于这个特定的设置可能会变得很重要。

libraryTarget:“amd-require”

这会将您的输出打包为立即执行的AMD需要（依赖项，工厂）包装器。

这个“amd-require”target允许使用AMD依赖项，而不需要单独的稍后调用。与'amd'目标，这取决于适当的要求功能在加载webpack输出的环境中可用。

对于此目标，将忽略库名称。

libraryTarget:“umd”

这将在所有模块定义下公开您的库，允许它与CommonJS、AMD一起工作，并作为全局变量。看看UMD存储库了解更多信息。

在这种情况下，您需要图书馆属性来命名模块：

模块.出口= {
  //...输出: {图书馆: “MyLibrary”,库目标: “嗯”,
  },
};

最后，输出是：

(功能 webpack通用模块定义(根,工厂) {
  如果 (类型出口=== '对象' && 类型模块=== '对象')模块.出口= 工厂();
  其他的 如果 (类型定义=== '功能' &&定义.amd公司) 定义([],工厂);
  其他的 如果 (类型出口=== '对象')出口[“MyLibrary”] = 工厂();
  其他的根[“MyLibrary”] = 工厂();
})(类型自己!== '未定义' ?自己: 这, 功能 () {
  返回_条目_返回_;
});

请注意，省略图书馆将导致入口点返回的所有属性的分配直接分配给根对象，如对象分配部分。示例：

模块.出口= {
  //...输出: {库目标: “嗯”,
  },
};

输出将是：

(功能 webpack通用模块定义(根,工厂) {
  如果 (类型出口=== '对象' && 类型模块=== '对象')模块.出口= 工厂();
  其他的 如果 (类型定义=== '功能' &&定义.amd公司) 定义([],工厂);
  其他的 {
    无功功率，无功功率一= 工厂();
    对于 (无功功率，无功功率我在里面一) (类型出口=== '对象' ?出口:根)[我] =一[我];
  }
})(类型自己!== '未定义' ?自己: 这, 功能 () {
  返回_条目_返回_;
});

自webpack 3.1.0以来，您可以为指定对象图书馆对于每个目标的不同名称：

模块.出口= {
  //...输出: {图书馆: {根: “MyLibrary”,amd公司: “我的名字”,公共设施: “我的普通图书馆”,
    },库目标: “嗯”,
  },
};

libraryTarget:'系统'

这将把你的库公开为系统注册器模块。此功能于年首次发布网络包4.30.0.

系统模块要求全局变量系统执行webpack捆绑包时，浏览器中会显示。正在编译到系统注册器格式允许您System.import（'/bundle.js'）无需额外配置，并将webpack捆绑包加载到系统模块注册表中。

模块.出口= {
  //...输出: {库目标: “系统”,
  },
};

输出：

系统.登记([], 功能 (_出口) {
  返回 {设置器: [],
    执行: 功能 () {
      // ...
    },
  };
});

通过添加输出库除了具有输出库目标设置为系统，输出捆绑包将库名称作为参数系统注册器:

系统.登记(“我的名字”, [], 功能 (_出口) {
  返回 {设置器: [],
    执行: 功能 () {
      // ...
    },
  };
});

您可以访问SystemJS上下文通过__系统上下文__:

//记录当前SystemJS模块的URL慰问.日志(__系统上下文__.元.网址);

//导入SystemJS模块，将当前SystemJS组件的url作为parentUrl__系统上下文__.进口('./其他文件.js').然后((米) => {慰问.日志(米);
});

其他目标

libraryTarget:“jsonp”

这将把入口点的返回值包装到jsonp包装器中。

我的图书馆(_条目_返回_);

库的依赖项将由外部配置。

输出模块

布尔值=false

将JavaScript文件输出为模块类型。默认情况下禁用，因为这是一个实验功能。

启用后，webpack将设置输出.ife到假,输出脚本类型到'模块'和terserOptions.模块到真的内部。

如果您正在使用webpack编译一个供他人使用的库，请确保设置输出库目标到'模块'什么时候输出模块是真的.

模块.出口= {
  //...实验: {输出模块: 真的,
  },输出: {模块: 真的,
  },
};

输出路径

string=路径联接（process.cwd（），'dist'）

输出目录作为绝对的路径。

webpack.config.js

常量路径= 要求(“路径”);模块.出口= {
  //...输出: {路径:路径.决定(__目录名, '距离/资产'),
  },
};

请注意[完整散列]在这个参数中将被一个散列的编译所取代。请参阅缓存指南了解详细信息。

输出路径信息

布尔值=真 string:“verbose”

告诉webpack在捆绑包中包含注释，其中包含有关所包含模块的信息。此选项默认为真的在里面发展和假在里面生产 模式分别是。“详细”显示了更多信息，如导出、运行时要求和紧急救援。

webpack.config.js

模块.出口= {
  //...输出: {返回文件路径的信息: 真的,
  },
};

输出公共路径

• 类型：

  • 功能

  • 一串

    输出公共路径默认为“自动”具有网状物和网络工作者目标，请参见本指南用于其用例。

当使用按需加载或加载图像、文件等外部资源时，这是一个重要的选项。如果指定了错误的值，则在加载这些资源时会收到404个错误。

此选项指定公共URL在浏览器中引用时输出目录的。相对URL相对于HTML页面进行解析（或<基础>标签）。服务器相关URL、协议相关URL或绝对URL也是可能的，有时也是必需的，例如在CDN上托管资产时。

该选项的值将作为运行时或加载程序创建的每个URL的前缀。因为这个此选项的值以结尾/在大多数情况下。

需要考虑的规则：您的URL输出路径从HTML页面的视图中。

webpack.config.js

常量路径= 要求('路径');模块.出口= {
  //...输出: {路径:路径.决定(__目录名, “公共/资产”),公共路径: 'https://cdn.example.com/assets/',
  },
};

对于此配置：

webpack.config.js

模块.出口= {
  //...输出: {公共路径: '/assets/',chunk文件名: '[id].cchunk.js',
  },
};

对块的请求如下所示/资产/4.chunk.js.

输出HTML的加载器可能会发出如下信号：

<链接 href公司="/资产/微调器.gif" />

或在CSS中加载图像时：

背景-图像: 网址(/资产/微调器.gif);

webpack-dev-server还接受来自公共路径，用于确定从何处提供输出文件。

请注意[完整散列]在此参数中，将替换为编译的哈希。请参阅缓存指南了解详细信息。

示例：

模块.出口= {
  //...输出: {
    //以下之一公共路径: “自动”, //它自动从`import.meta.url`、`document.currentScript`、`<script/>`或`self.location`中确定公共路径。公共路径: 'https://cdn.example.com/assets/', //CDN（总是HTTPS）公共路径: “//cdn.example.com/assets/”, //CDN（相同协议）公共路径: '/assets/', //服务器相关公共路径: '资产/', //相对于HTML页面公共路径: '../资产/', //相对于HTML页面公共路径: '', //相对于HTML页面（同一目录）
  },
};

在以下情况下公共路径的输出文件在编译时不知道，可以保留为空，并在运行时使用自由变量 __网络包公共路径__.

__网络包公共路径__=myRuntime公共路径;

//应用程序条目的其余部分

请参见这次讨论有关的详细信息__网络包公共路径__.

输出脚本类型

string:'模块'|'文本/javascript' 布尔值=false

此选项允许使用自定义脚本类型加载异步块，例如<script type=“模块”…>.

模块.出口= {
  //...输出: {脚本类型: '模块',
  },
};

output.sourceMap文件名

字符串=“[文件].map[查询]”

配置如何命名源映射。仅在以下情况下生效开发工具设置为'源映射'，写入输出文件。

这个[姓名],[标识],[完整散列]和[春喀什语]替换输出.filename可以使用。除此之外，您还可以使用中Filenamelevel下列出的替换模板字符串.

output.sourcePrefix（输出源前缀）

字符串=“”

更改输出包中每一行的前缀。

webpack.config.js

模块.出口= {
  //...输出: {源前缀: “\t”,
  },
};

输出严格模块错误处理

根据EcmaScript Modules规范处理模块加载错误，但需要付出性能代价。

• 类型：布尔值
• 可用：5.25.0+

模块.出口= {
  //...输出: {strictModule错误处理: 真的,
  },
};

output.stritModule异常处理

布尔值=false

告诉webpack从模块实例缓存中删除模块(必需品缓存)如果发生异常要求d。

默认为假出于性能原因。

设置为时假，模块没有从缓存中删除，这导致只在第一个模块上引发异常要求调用（使其与node.js不兼容）。

例如，考虑模块.js:

扔 新的 错误(“错误”);

使用strictModule异常处理设置为假，只有第一个要求引发异常：

//使用strictModuleExceptionHandling=false
要求('模块'); //<-抛出
要求('模块'); //<-不扔

相反，使用strictModule异常处理设置为真的，全部要求此模块的引发异常：

//strictModuleExceptionHandling=true时
要求('模块'); //<-抛出
要求('模块'); //<-还抛出

output.trustedTypes（输出可信类型）

真的 一串 对象

5.37.0+

控制受信任的类型兼容性。启用后，webpack将检测受信任类型支持，如果受支持，则使用受信任类型策略创建其动态加载的脚本URL。当应用程序在所需的可信类型内容安全策略指令。

默认情况下它是禁用的（没有兼容性，脚本URL是字符串）。

• 设置为时真的，webpack将使用输出唯一名称作为受信任类型策略名称。
• 当设置为非空字符串时，其值将用作策略名称。
• 设置为对象时，策略名称取自对象的策略名称财产。

webpack.config.js

模块.出口= {
  //...输出: {
    //...受信任的类型: {策略名称: '我的应用程序#webpack',
    },
  },
};

output.trustedTypes.onPolicyCreation失败

string='stop'：'继续'|'停止'

5.82.0+

确定是否在预期情况下继续装载“脚本”的require-trusted-types调用时未强制执行或立即失败trustedTypes.createPolicy（…）由于CSP中缺少策略名称而失败受信任的类型列表或重复。

模块.出口= {
  //...输出: {
    //...受信任的类型: {策略名称: '我的应用程序#webpack',onPolicyCreation失败: “继续”,
    },
  },
};

输出.umdNamedDefine

布尔值

使用时库目标：“umd”，设置output.umdNamed定义到真的将命名UMD构建的AMD模块。否则为匿名定义使用。

模块.出口= {
  //...输出: {umd名称定义: 真的,
  },
};

输出唯一名称

一串

webpack构建的唯一名称，以避免在使用全局变量时多个webpack运行时发生冲突。默认为输出库名称或来自的包名称package.json包在上下文中，如果两者都找不到，则将其设置为''.

输出唯一名称将用于为以下对象生成唯一全局变量：

• output.chunk加载全局

webpack.config.js

模块.出口= {
  // ...输出: {唯一名称: “my-package-xyz”,
  },
};

output.wasm加载

假 “fetch-streaming”|“fetch”|“异步模式” 一串

选项设置加载WebAssembly模块的方法。默认情况下包括的方法有'获取'（web/WebWorker），'异步节点'（Node.js），但其他可能是通过插件添加的。

默认值可能受不同的目标:

• 默认为“获取”如果目标设置为“网页”,'网络工作者',“电子渲染器”或'节点webkit'.
• 默认为'异步节点'如果目标设置为'节点','异步节点',“电子主电源”或“电子预加载”.

模块.出口= {
  //...输出: {wasm正在加载: “获取”,
  },
};

输出.webassemblyModuleFilename

字符串=“[hash].module.wasm”

指定WebAssembly模块的文件名。它应该在输出路径目录

模块.出口= {
  //...输出: {Web组件模块文件名: '[id]。[散列].wasm',
  },
};

output.workerChunk加载

string:“require”|“import-scripts”|“async-node”|“导入”|“universal” 布尔值：false

新选项workerChunk加载控制工人的区块加载。

webpack.config.js

模块.出口= {
  //...输出: {workerChunkLoading（工人阻塞加载）: 假,
  },
};

输出.workerPublicPath

一串

为Worker设置公共路径，默认值为输出公共路径。只有当辅助脚本与其他脚本位于不同的路径时，才使用此选项。

webpack.config.js

模块.出口= {
  //...输出: {worker公共路径: '/workerPublicPath2/',
  },
};

output.workerWasm加载

假 “fetch-streaming”|“fetch”|“异步模式” 一串

选项设置在workers中加载WebAssembly模块的方法，默认值为输出.wasm加载.

webpack.config.js

模块.出口= {
  //...输出: {worker Wasm加载: “获取”,
  },
};