webpack 5.107.2 → 5.108.0

package/lib/config/defaults.js

@@ -103,6 +103,7 @@ const {
  * devtoolNamespace: NonNullable<Output["devtoolNamespace"]>,
  * publicPath: NonNullable<Output["publicPath"]>,
  * workerPublicPath: NonNullable<Output["workerPublicPath"]>,
+ * workerChunkFilename: NonNullable<Output["workerChunkFilename"]>,
  * workerWasmLoading: NonNullable<Output["workerWasmLoading"]>,
  * workerChunkLoading: NonNullable<Output["workerChunkLoading"]>,
  * chunkFormat: NonNullable<Output["chunkFormat"]>,
@@ -123,6 +124,7 @@ const {
  * compareBeforeEmit: NonNullable<Output["compareBeforeEmit"]>,
  * strictModuleErrorHandling: NonNullable<Output["strictModuleErrorHandling"]>,
  * strictModuleExceptionHandling: NonNullable<Output["strictModuleExceptionHandling"]>,
+ * strictModuleResolution: NonNullable<Output["strictModuleResolution"]>,
  * importFunctionName: NonNullable<Output["importFunctionName"]>,
  * importMetaName: NonNullable<Output["importMetaName"]>,
  * environment: RecursiveNonNullable<Output["environment"]>,
@@ -160,6 +162,7 @@ const {
  * usedExports: NonNullable<Optimization["usedExports"]>,
  * mangleExports: NonNullable<Optimization["mangleExports"]>,
  * innerGraph: NonNullable<Optimization["innerGraph"]>,
+ * inlineExports: NonNullable<Optimization["inlineExports"]>,
  * concatenateModules: NonNullable<Optimization["concatenateModules"]>,
  * avoidEntryIife: NonNullable<Optimization["avoidEntryIife"]>,
  * emitOnErrors: NonNullable<Optimization["emitOnErrors"]>,
@@ -525,6 +528,9 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			css:
 				/** @type {NonNullable<ExperimentsNormalized["css"]>} */
 				(options.experiments.css),
+			html:
+				/** @type {NonNullable<ExperimentsNormalized["html"]>} */
+				(options.experiments.html),
 			typescript:
 				/** @type {NonNullable<ExperimentsNormalized["typescript"]>} */
 				(options.experiments.typescript)
@@ -546,8 +552,13 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 						browser: targetProperties.browser,
 						webworker: targetProperties.webworker,
 						node: targetProperties.node,
+						deno: targetProperties.deno,
+						bun: targetProperties.bun,
 						nwjs: targetProperties.nwjs,
-						electron: targetProperties.electron
+						electron: targetProperties.electron,
+						// spans both web and node (target "universal" or ["web", "node"])
+						universal:
+							targetProperties.node === null && targetProperties.web === null
 					}
 	};
 };
@@ -570,7 +581,19 @@ const applyExperimentsDefaults = (
 	// TODO do we need sync web assembly in webpack@6?
 	D(experiments, "syncWebAssembly", false);
 	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
-	D(experiments, "outputModule", false);
+	// the universal target (web + node, neither specific) only works as ESM
+	const universal =
+		Boolean(targetProperties) &&
+		/** @type {TargetProperties} */ (targetProperties).node === null &&
+		/** @type {TargetProperties} */ (targetProperties).web === null;
+	// the deno and bun targets only emit ECMAScript modules
+	const deno =
+		Boolean(targetProperties) &&
+		/** @type {TargetProperties} */ (targetProperties).deno === true;
+	const bun =
+		Boolean(targetProperties) &&
+		/** @type {TargetProperties} */ (targetProperties).bun === true;
+	D(experiments, "outputModule", universal || deno || bun);
 	D(experiments, "lazyCompilation", undefined);
 	D(experiments, "buildHttp", undefined);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
@@ -1090,6 +1113,18 @@ const applyModuleDefaults = (
 		// modules (including imported ones); `extract: false` disables it
 		// everywhere.
 		F(module.generator, HTML_MODULE_TYPE, () => ({}));
+		// `module.parser.html.sources` defaults to `true` — HtmlParser uses
+		// the built-in source list to extract URL-like attributes (`<img
+		// src>`, `<link href>`, `<script src>`, …) as webpack dependencies.
+		// Users may pass `false` to disable extraction entirely or an array
+		// (with `"..."` to include the defaults) to customize it.
+		F(module.parser, HTML_MODULE_TYPE, () => ({}));
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[HTML_MODULE_TYPE]>} */
+			(module.parser[HTML_MODULE_TYPE]),
+			"sources",
+			true
+		);
 	}
 
 	A(module, "defaultRules", () => {
@@ -1268,6 +1303,18 @@ const applyModuleDefaults = (
 				type: HTML_MODULE_TYPE,
 				resolve
 			});
+			// `<iframe srcdoc>` content is fed back through the HTML pipeline as a
+			// `data:text/html` module. `extract: "inline"` exposes the processed
+			// HTML on the `html` codegen channel that `HtmlInlineHtmlDependency.
+			// Template` reads back into the attribute, without emitting a standalone
+			// `.html` file (the module is never a page on its own).
+			rules.push({
+				dependency: "html-srcdoc",
+				generator: {
+					extract: "inline"
+				},
+				resolve
+			});
 			if (css) {
 				// Inline `<style>` content in an HTML module is fed into the
 				// CSS pipeline as a `data:text/css` virtual module. We force
@@ -1282,6 +1329,16 @@ const applyModuleDefaults = (
 					},
 					resolve
 				});
+				// A `style="..."` attribute is a CSS block's contents, not a
+				// stylesheet, so parse it as one (`as: "block-contents"`).
+				rules.push({
+					dependency: "html-style-attribute",
+					parser: {
+						exportType: "text",
+						as: "block-contents"
+					},
+					resolve
+				});
 			}
 		}
 
@@ -1452,6 +1509,17 @@ const applyOutputDefaults = (
 		"globalThis",
 		() => /** @type {boolean | undefined} */ (tp && tp.globalThis)
 	);
+	F(
+		environment,
+		"symbol",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.symbol))
+	);
+	F(
+		environment,
+		"hasOwn",
+		// No optimistic, because it is new
+		() => tp && /** @type {boolean | undefined} */ (tp.hasOwn)
+	);
 	F(
 		environment,
 		"bigIntLiteral",
@@ -1463,6 +1531,22 @@ const applyOutputDefaults = (
 		"const",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
 	);
+	// `let` was added after `const`; targets predating it report only `const`,
+	// so fall back to `const` when `let` is unreported (undefined). Targets that
+	// do report `let` (browserslist, built-ins) keep their own accurate value.
+	F(environment, "let", () =>
+		conditionallyOptimistic(
+			/** @type {boolean | undefined} */ (tp && tp.let),
+			environment.const
+		)
+	);
+	F(
+		environment,
+		"logicalAssignment",
+		() =>
+			// No optimistic, because it is new
+			tp && /** @type {boolean | undefined} */ (tp.logicalAssignment)
+	);
 	F(
 		environment,
 		"methodShorthand",
@@ -1498,6 +1582,11 @@ const applyOutputDefaults = (
 		() =>
 			tp && optimistic(/** @type {boolean | undefined} */ (tp.optionalChaining))
 	);
+	F(
+		environment,
+		"spread",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.spread))
+	);
 	F(
 		environment,
 		"nodePrefixForCoreModules",
@@ -1514,6 +1603,13 @@ const applyOutputDefaults = (
 			// No optimistic, because it is new
 			tp && /** @type {boolean | undefined} */ (tp.importMetaDirnameAndFilename)
 	);
+	F(
+		environment,
+		"nodeBuiltinModuleGetter",
+		() =>
+			// No optimistic, because it is new
+			tp && /** @type {boolean | undefined} */ (tp.nodeBuiltinModuleGetter)
+	);
 	F(
 		environment,
 		"templateLiteral",
@@ -1619,6 +1715,7 @@ const applyOutputDefaults = (
 		}
 		return "[name].html";
 	});
+	D(output, "html", false);
 	D(output, "assetModuleFilename", "[hash][ext][query][fragment]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
 	D(output, "compareBeforeEmit", true);
@@ -1633,7 +1730,10 @@ const applyOutputDefaults = (
 			if (tp.global) return "global";
 			if (tp.globalThis) return "globalThis";
 			// For universal target (i.e. code can be run in browser/node/worker etc.)
-			if (tp.web === null && tp.node === null && tp.module) return "globalThis";
+			// `tp.module` is unset for a version-less universal target, so key off ESM output
+			if (tp.web === null && tp.node === null && output.module) {
+				return "globalThis";
+			}
 		}
 		return "self";
 	});
@@ -1700,6 +1800,13 @@ const applyOutputDefaults = (
 		}
 		return false;
 	});
+	F(
+		output,
+		"workerChunkFilename",
+		() =>
+			/** @type {NonNullable<Output["workerChunkFilename"]>} */
+			(output.chunkFilename)
+	);
 	F(output, "workerChunkLoading", () => {
 		if (tp) {
 			switch (output.chunkFormat) {
@@ -1781,6 +1888,7 @@ const applyOutputDefaults = (
 	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
 	D(output, "strictModuleErrorHandling", false);
 	D(output, "strictModuleExceptionHandling", false);
+	F(output, "strictModuleResolution", () => development);
 
 	const { trustedTypes } = output;
 	if (trustedTypes) {
@@ -1888,7 +1996,25 @@ const applyExternalsPresetsDefaults = (
 		externalsPresets,
 		"node",
 		/** @type {boolean | undefined} */
-		(targetProperties && (targetProperties.node || isUniversal("node")))
+		(
+			targetProperties &&
+				((targetProperties.node &&
+					!targetProperties.deno &&
+					!targetProperties.bun) ||
+					isUniversal("node"))
+		)
+	);
+	D(
+		externalsPresets,
+		"deno",
+		/** @type {boolean | undefined} */
+		(Boolean(targetProperties && targetProperties.deno))
+	);
+	D(
+		externalsPresets,
+		"bun",
+		/** @type {boolean | undefined} */
+		(Boolean(targetProperties && targetProperties.bun))
 	);
 	D(
 		externalsPresets,
@@ -1952,6 +2078,8 @@ const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 				return "electron";
 			}
 			if (targetProperties.nwjs) return "nwjs";
+			if (targetProperties.deno) return "deno";
+			if (targetProperties.bun) return "bun";
 			if (targetProperties.node) return "node";
 			if (targetProperties.web) return "web";
 		}
@@ -2051,6 +2179,7 @@ const applyOptimizationDefaults = (
 	D(optimization, "providedExports", true);
 	D(optimization, "usedExports", production);
 	D(optimization, "innerGraph", production);
+	D(optimization, "inlineExports", production);
 	D(optimization, "mangleExports", production);
 	D(optimization, "concatenateModules", production);
 	D(optimization, "avoidEntryIife", production);
@@ -2064,8 +2193,8 @@ const applyOptimizationDefaults = (
 	A(optimization, "minimizer", () => [
 		{
 			apply: (compiler) => {
-				// Lazy load the Terser plugin
-				const TerserPlugin = require("terser-webpack-plugin");
+				// Lazy load the minimizer plugin
+				const TerserPlugin = require("minimizer-webpack-plugin");
 
 				new TerserPlugin({
 					terserOptions: {
@@ -2125,6 +2254,7 @@ const applyOptimizationDefaults = (
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Mode} options.mode mode
  * @param {boolean} options.css is css enabled
+ * @param {boolean} options.html is html enabled
  * @param {boolean} options.typescript is typescript enabled
  * @returns {ResolveOptions} resolve options
  */
@@ -2134,6 +2264,7 @@ const getResolveDefaults = ({
 	targetProperties,
 	mode,
 	css,
+	html,
 	typescript
 }) => {
 	/** @type {string[]} */
@@ -2142,6 +2273,8 @@ const getResolveDefaults = ({
 	conditions.push(mode === "development" ? "development" : "production");
 
 	if (targetProperties) {
+		if (targetProperties.deno) conditions.push("deno");
+		if (targetProperties.bun) conditions.push("bun");
 		if (targetProperties.webworker) conditions.push("worker");
 		if (targetProperties.node) conditions.push("node");
 		if (targetProperties.web) conditions.push("browser");
@@ -2153,6 +2286,13 @@ const getResolveDefaults = ({
 		? [".ts", ".js", ".json", ".wasm"]
 		: [".js", ".json", ".wasm"];
 
+	// HTML-first when enabled: `.html` outranks `.js`, `.css` is the last fallback.
+	const esmResolveExtensions = [
+		...(html ? [".html"] : []),
+		...jsExtensions,
+		...(css ? [".css"] : [])
+	];
+
 	const tp = targetProperties;
 	const browserField =
 		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
@@ -2186,7 +2326,7 @@ const getResolveDefaults = ({
 			"module",
 			"..."
 		],
-		extensions: [...jsExtensions]
+		extensions: [...esmResolveExtensions]
 	});
 
 	/** @type {() => ResolveOptions} */

package/lib/config/defineConfig.js

@@ -0,0 +1,31 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} Configuration */
+/** @typedef {import("../MultiCompiler").MultiWebpackOptions} MultiConfiguration */
+
+/**
+ * @template T
+ * @typedef {T | Promise<T>} MaybePromise
+ */
+
+/**
+ * Function style configuration, called with the `--env` values and CLI arguments.
+ * @typedef {(env: Record<string, EXPECTED_ANY>, argv: Record<string, EXPECTED_ANY>) => MaybePromise<Configuration | MultiConfiguration>} ConfigurationFactory
+ */
+
+/** @typedef {MaybePromise<Configuration | MultiConfiguration | ConfigurationFactory | ConfigurationFactory[]>} DefineConfigInput */
+
+/**
+ * A type helper for authoring configuration files, no-op at runtime.
+ * @template {DefineConfigInput} T
+ * @param {T} config webpack configuration
+ * @returns {T} the same configuration
+ */
+const defineConfig = (config) => config;
+
+module.exports = defineConfig;

package/lib/config/normalization.js

@@ -368,6 +368,7 @@ const getNormalizedWebpackOptions = (config) => ({
 			hotUpdateChunkFilename: output.hotUpdateChunkFilename,
 			hotUpdateGlobal: output.hotUpdateGlobal,
 			hotUpdateMainFilename: output.hotUpdateMainFilename,
+			html: output.html,
 			htmlChunkFilename: output.htmlChunkFilename,
 			htmlFilename: output.htmlFilename,
 			ignoreBrowserWarnings: output.ignoreBrowserWarnings,
@@ -407,6 +408,7 @@ const getNormalizedWebpackOptions = (config) => ({
 			sourcePrefix: output.sourcePrefix,
 			strictModuleErrorHandling: output.strictModuleErrorHandling,
 			strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+			strictModuleResolution: output.strictModuleResolution,
 			trustedTypes: optionalNestedConfig(
 				output.trustedTypes,
 				(trustedTypes) => {
@@ -421,6 +423,7 @@ const getNormalizedWebpackOptions = (config) => ({
 			wasmLoading: output.wasmLoading,
 			webassemblyModuleFilename: output.webassemblyModuleFilename,
 			workerPublicPath: output.workerPublicPath,
+			workerChunkFilename: output.workerChunkFilename,
 			workerChunkLoading: output.workerChunkLoading,
 			workerWasmLoading: output.workerWasmLoading
 		};
@@ -551,6 +554,7 @@ const getNormalizedEntryStatic = (entry) => {
 							(Array.isArray(value.import) ? value.import : [value.import])
 					),
 				filename: value.filename,
+				html: value.html,
 				layer: value.layer,
 				runtime: value.runtime,
 				baseUri: value.baseUri,
@@ -558,6 +562,7 @@ const getNormalizedEntryStatic = (entry) => {
 				chunkLoading: value.chunkLoading,
 				asyncChunks: value.asyncChunks,
 				wasmLoading: value.wasmLoading,
+				worker: value.worker,
 				dependOn:
 					/** @type {EntryDescriptionNormalized["dependOn"]} */
 					(