webpack 5.106.2 → 5.107.0

package/lib/dependencies/CssIcssSymbolDependency.js

@@ -30,13 +30,15 @@ class CssIcssSymbolDependency extends NullDependency {
 	 * @param {Range} range range
 	 * @param {string=} value value when it was defined in this module
 	 * @param {string=} importName import name when it was imported from other module
+	 * @param {string=} request request of the `@value` import that was active when this reference was parsed — used to disambiguate when the same local name is imported from multiple modules
 	 */
-	constructor(localName, range, value, importName) {
+	constructor(localName, range, value, importName, request) {
 		super();
 		this.localName = localName;
 		this.range = range;
 		this.value = value;
 		this.importName = importName;
+		this.request = request;
 		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
@@ -53,7 +55,10 @@ class CssIcssSymbolDependency extends NullDependency {
 	 */
 	updateHash(hash, context) {
 		if (this._hashUpdate === undefined) {
-			this._hashUpdate = `${this.range}${this.localName}${this.value || this.importName}`;
+			// Concatenate with explicit field separators so adjacent fields
+			// can't alias each other (e.g. range `[1,11]` + localName `"foo"`
+			// vs range `[1,1]` + localName `"1foo"`).
+			this._hashUpdate = `range|${JSON.stringify(this.range)}|localName|${this.localName}|value|${this.value || ""}|importName|${this.importName || ""}|request|${this.request || ""}`;
 		}
 		hash.update(this._hashUpdate);
 	}
@@ -68,6 +73,7 @@ class CssIcssSymbolDependency extends NullDependency {
 		write(this.range);
 		write(this.value);
 		write(this.importName);
+		write(this.request);
 		super.serialize(context);
 	}
 
@@ -81,6 +87,7 @@ class CssIcssSymbolDependency extends NullDependency {
 		this.range = read();
 		this.value = read();
 		this.importName = read();
+		this.request = read();
 		super.deserialize(context);
 	}
 }
@@ -103,7 +110,8 @@ CssIcssSymbolDependency.Template = class CssIcssSymbolDependencyTemplate extends
 				? CssIcssExportDependency.Template.resolve(
 						dep.localName,
 						dep.importName,
-						templateContext
+						templateContext,
+						dep.request
 					)
 				: dep.value;
 

package/lib/dependencies/CssImportDependency.js

@@ -43,6 +43,14 @@ class CssImportDependency extends ModuleDependency {
 		return `css-import${this.mode ? `-${this.mode}-module` : ""}`;
 	}
 
+	/**
+	 * Returns true if this dependency can be concatenated
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate() {
+		return true;
+	}
+
 	/**
 	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests

package/lib/dependencies/CssUrlDependency.js

@@ -12,14 +12,17 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 const getIgnoredRawDataUrlModule = memoize(
@@ -56,6 +59,27 @@ class CssUrlDependency extends ModuleDependency {
 		return getIgnoredRawDataUrlModule();
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// The dependency template substitutes the referenced asset's hashed
+		// filename into the rendered CSS at code-generation time. Folding the
+		// asset module's content hash into the dependency hash ensures the
+		// CSS module's hash invalidates — and the CSS chunk's contenthash
+		// updates — whenever the referenced asset's content changes.
+		const { chunkGraph } = context;
+		const module = chunkGraph.moduleGraph.getModule(this);
+		if (!module) return;
+		const buildInfo = /** @type {BuildInfo | undefined} */ (module.buildInfo);
+		if (buildInfo && buildInfo.hash) {
+			hash.update(/** @type {string} */ (buildInfo.hash));
+		}
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
@@ -192,5 +216,6 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
 
 CssUrlDependency.PUBLIC_PATH_AUTO = "__WEBPACK_CSS_PUBLIC_PATH_AUTO__";
+CssUrlDependency.PUBLIC_PATH_FULL_HASH = "__WEBPACK_CSS_PUBLIC_PATH_FULL_HASH_";
 
 module.exports = CssUrlDependency;

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const EnvironmentNotSupportAsyncWarning = require("../EnvironmentNotSupportAsyncWarning");
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
+const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSupportAsyncWarning");
 const DynamicExports = require("./DynamicExports");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 const HarmonyExports = require("./HarmonyExports");

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const CompatibilityPlugin = require("../CompatibilityPlugin");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { getImportAttributes } = require("../javascript/JavascriptParser");
 const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
@@ -144,12 +144,13 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						: undefined
 			);
 			dep.isAnonymousDefault =
-				node.type === "ArrowFunctionExpression" ||
-				((node.type === "FunctionDeclaration" ||
-					node.type === "FunctionExpression" ||
-					node.type === "ClassDeclaration" ||
-					node.type === "ClassExpression") &&
-					!node.id);
+				this.options.anonymousDefaultExportName !== false &&
+				(node.type === "ArrowFunctionExpression" ||
+					((node.type === "FunctionDeclaration" ||
+						node.type === "FunctionExpression" ||
+						node.type === "ClassDeclaration" ||
+						node.type === "ClassExpression") &&
+						!node.id));
 			dep.loc = Object.create(
 				/** @type {DependencyLocation} */ (statement.loc)
 			);

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -143,18 +143,17 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				);
 			}
 
+			const used = concatenationScope
+				? undefined
+				: moduleGraph.getExportsInfo(module).getUsedName("default", runtime);
+
 			if (concatenationScope) {
 				concatenationScope.registerExport("default", name);
-			} else {
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName("default", runtime);
-				if (used) {
-					/** @type {ExportMap} */
-					const map = new Map();
-					map.set(used, `/* export default binding */ ${name}`);
-					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
-				}
+			} else if (used) {
+				/** @type {ExportMap} */
+				const map = new Map();
+				map.set(used, `/* export default binding */ ${name}`);
+				initFragments.push(new HarmonyExportInitFragment(exportsName, map));
 			}
 
 			source.replace(
@@ -163,12 +162,17 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				`/* harmony default export */ ${dep.prefix}`
 			);
 
-			if (typeof declarationId !== "string" && dep.isAnonymousDefault) {
+			if (
+				typeof declarationId !== "string" &&
+				dep.isAnonymousDefault &&
+				(concatenationScope || used)
+			) {
 				// Fix .name for anonymous default export function declarations
 				// see test/test262-cases/test/language/module-code/instn-named-bndng-dflt-fun-anon.js cspell:disable-line
+				runtimeRequirements.add(RuntimeGlobals.setAnonymousDefaultName);
 				initFragments.push(
 					new InitFragment(
-						`Object.defineProperty(${name}, "name", { value: "default", configurable: true });\n`,
+						`${RuntimeGlobals.setAnonymousDefaultName}(${name});\n`,
 						InitFragment.STAGE_HARMONY_EXPORTS,
 						2
 					)
@@ -178,6 +182,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 			/** @type {string} */
 			let content;
 			let name = ConcatenationScope.DEFAULT_EXPORT;
+			let defaultIsUsed = Boolean(concatenationScope);
 			if (runtimeTemplate.supportsConst()) {
 				content = `/* harmony default export */ const ${name} = `;
 				if (concatenationScope) {
@@ -187,6 +192,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 						.getExportsInfo(module)
 						.getUsedName("default", runtime);
 					if (used) {
+						defaultIsUsed = true;
 						runtimeRequirements.add(RuntimeGlobals.exports);
 						/** @type {ExportMap} */
 						const map = new Map();
@@ -204,6 +210,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 					.getExportsInfo(module)
 					.getUsedName("default", runtime);
 				if (used) {
+					defaultIsUsed = true;
 					runtimeRequirements.add(RuntimeGlobals.exports);
 					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
 					// No local `__WEBPACK_DEFAULT_EXPORT__` binding is created in this path,
@@ -224,13 +231,14 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 					dep.range[0] - 1,
 					`${content}(${dep.prefix}`
 				);
-				if (dep.isAnonymousDefault) {
+				if (dep.isAnonymousDefault && defaultIsUsed) {
 					// Fix .name for anonymous default export expressions
 					// see test/test262-cases/test/language/module-code/eval-export-dflt-cls-anon.js cspell:disable-line
+					runtimeRequirements.add(RuntimeGlobals.setAnonymousDefaultName);
 					source.replace(
 						dep.range[1],
 						dep.rangeStatement[1] - 0.5,
-						`);\n(Object.getOwnPropertyDescriptor(${name}, "name") || {}).writable || Object.defineProperty(${name}, "name", { value: "default", configurable: true });`
+						`);\n${RuntimeGlobals.setAnonymousDefaultName}(${name});`
 					);
 				} else {
 					source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -8,7 +8,6 @@
 const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
 const { UsageState } = require("../ExportsInfo");
-const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
@@ -26,6 +25,7 @@ const {
 } = require("../util/runtime");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const processExportInfo = require("./processExportInfo");
 
@@ -50,7 +50,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -128,6 +128,79 @@ class ExportMode {
 
 /** @typedef {number[]} DependencyIndices */
 
+const RETURNS_TRUE = () => true;
+
+/**
+ * Detect a per-name cycle when collecting `export *` contributions from
+ * `exportInfo`'s module into `parentModule`. The TC39 `ResolveExport`
+ * algorithm tracks a `resolveSet` of `(module, exportName)` pairs and
+ * returns null when an entry is revisited — letting the `StarExportEntries`
+ * loop fall through to a non-cyclic source. Webpack's static export graph
+ * does not run that resolution algorithm, so we approximate it: if the
+ * imported module's same-named export ultimately re-exports from
+ * `parentModule` under the same name, the star contribution is cyclic and
+ * must be skipped. The non-cyclic alternative (a sibling `export *` that
+ * provides a real binding) then wins.
+ *
+ * We walk the target chain one hop at a time using `findTarget` with a
+ * "match anything" filter so we can guard against namespace targets
+ * (`export * as ns from`, where `target.export` is undefined) and against
+ * unrelated cycles in the graph that would otherwise loop forever inside
+ * `_findTarget`.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ExportInfo} exportInfo export info on the imported module
+ * @param {Module} parentModule the module that contains the star reexport
+ * @returns {boolean} true when this export reexports back to the parent module under the same name
+ */
+const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
+	// Fast path: probe the first hop directly. The overwhelmingly common case
+	// in real builds is a terminal local binding (no `_target`) — `findTarget`
+	// returns `undefined` and we exit without allocating a `visited` set.
+	const firstTarget = exportInfo.findTarget(moduleGraph, RETURNS_TRUE);
+	if (!firstTarget || typeof firstTarget !== "object") return false;
+	const name = exportInfo.name;
+	if (
+		firstTarget.module === parentModule &&
+		Array.isArray(firstTarget.export) &&
+		firstTarget.export.length === 1 &&
+		firstTarget.export[0] === name
+	) {
+		return true;
+	}
+	if (!Array.isArray(firstTarget.export) || firstTarget.export.length === 0) {
+		return false;
+	}
+	// Multi-hop chain — allocate visited tracking now. The set protects against
+	// unrelated cycles in the graph that would otherwise spin inside
+	// `_findTarget` (its `alreadyVisited` is only seeded for the entry node).
+	let current = moduleGraph
+		.getExportsInfo(firstTarget.module)
+		.getReadOnlyExportInfo(firstTarget.export[0]);
+	/** @type {Set<ExportInfo>} */
+	const visited = new Set([exportInfo, current]);
+	for (;;) {
+		const target = current.findTarget(moduleGraph, RETURNS_TRUE);
+		if (!target || typeof target !== "object") return false;
+		if (
+			target.module === parentModule &&
+			Array.isArray(target.export) &&
+			target.export.length === 1 &&
+			target.export[0] === name
+		) {
+			return true;
+		}
+		if (!Array.isArray(target.export) || target.export.length === 0) {
+			return false;
+		}
+		const next = moduleGraph
+			.getExportsInfo(target.module)
+			.getReadOnlyExportInfo(target.export[0]);
+		if (visited.has(next)) return false;
+		visited.add(next);
+		current = next;
+	}
+};
+
 /**
  * Determine export assignments.
  * @param {ModuleGraph} moduleGraph module graph
@@ -149,6 +222,11 @@ const determineExportAssignments = (
 		dependencies = [...dependencies, additionalDependency];
 	}
 
+	const referenceDep = dependencies[0] || additionalDependency;
+	const parentModule = referenceDep
+		? moduleGraph.getParentModule(referenceDep)
+		: null;
+
 	for (const dep of dependencies) {
 		const i = dependencyIndices.length;
 		dependencyIndices[i] = names.size;
@@ -159,7 +237,11 @@ const determineExportAssignments = (
 				if (
 					exportInfo.provided === true &&
 					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name)
+					!names.has(exportInfo.name) &&
+					!(
+						parentModule &&
+						isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
+					)
 				) {
 					names.add(exportInfo.name);
 					dependencyIndices[i] = names.size;
@@ -535,6 +617,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		/** @type {Hidden | undefined} */
 		const hidden = hiddenExports !== undefined ? new Set() : undefined;
 
+		const parentModule = /** @type {Module} */ (
+			moduleGraph.getParentModule(this)
+		);
+
 		if (noExtraImports) {
 			for (const exportInfo of exportsInfo.orderedExports) {
 				const name = exportInfo.name;
@@ -544,10 +630,22 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					importedExportsInfo.getReadOnlyExportInfo(name);
 				if (importedExportInfo.provided === false) continue;
 				if (hiddenExports !== undefined && hiddenExports.has(name)) {
+					// Earlier star deps already provided this name non-cyclically
+					// (`determineExportAssignments` filters cyclic candidates), so
+					// the cycle check below would be wasted work.
 					/** @type {Hidden} */
 					(hidden).add(name);
 					continue;
 				}
+				if (
+					isStarReexportBackToParent(
+						moduleGraph,
+						importedExportInfo,
+						parentModule
+					)
+				) {
+					continue;
+				}
 				exports.add(name);
 				if (importedExportInfo.provided === true) continue;
 				checked.add(name);
@@ -564,6 +662,15 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					(hidden).add(name);
 					continue;
 				}
+				if (
+					isStarReexportBackToParent(
+						moduleGraph,
+						importedExportInfo,
+						parentModule
+					)
+				) {
+					continue;
+				}
 				exports.add(name);
 				if (importedExportInfo.provided === true) continue;
 				checked.add(name);

package/lib/dependencies/HarmonyImportDependency.js

@@ -7,11 +7,11 @@
 
 const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
-const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
+const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
@@ -23,7 +23,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -112,6 +112,14 @@ class HarmonyImportDependency extends ModuleDependency {
 		return "esm";
 	}
 
+	/**
+	 * Returns true if this dependency can be concatenated
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate() {
+		return true;
+	}
+
 	/**
 	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const {
 	VariableInfo,
 	getImportAttributes
@@ -413,6 +413,27 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					return true;
 				}
 			);
+		// Per the TC39 import-defer spec, [[Set]] on a Module Namespace
+		// Exotic Object returns false without triggering evaluation. The
+		// default expressionMemberChain path produces `<importVar>.a.foo`
+		// whose `.a` getter eagerly requires (and thus evaluates) the
+		// deferred module. For top-level `ns.foo = value`, walk only the
+		// bare `ns` identifier so it gets replaced with the deferred
+		// namespace proxy (whose set trap returns false), and leave the
+		// `.foo = value` part as plain code.
+		parser.hooks.assignMemberChain
+			.for(harmonySpecifierTag)
+			.tap(PLUGIN_NAME, (expression, members) => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
+				if (expression.operator !== "=") return;
+				if (members.length !== 1) return;
+				const left = /** @type {MemberExpression} */ (expression.left);
+				if (left.object.type !== "Identifier") return;
+				parser.walkExpression(expression.right);
+				parser.walkExpression(left.object);
+				return true;
+			});
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
 		hotAcceptCallback.tap(PLUGIN_NAME, (expr, requests) => {

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -27,7 +27,7 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */

package/lib/{HarmonyLinkingError.js → dependencies/HarmonyLinkingError.js}

@@ -4,9 +4,9 @@
 
 "use strict";
 
-const WebpackError = require("./WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
-module.exports = class HarmonyLinkingError extends WebpackError {
+class HarmonyLinkingError extends WebpackError {
 	/** @param {string} message Error message */
 	constructor(message) {
 		super(message);
@@ -14,4 +14,6 @@ module.exports = class HarmonyLinkingError extends WebpackError {
 		this.name = "HarmonyLinkingError";
 		this.hideStack = true;
 	}
-};
+}
+
+module.exports = HarmonyLinkingError;

package/lib/dependencies/HtmlInlineScriptDependency.js

@@ -0,0 +1,133 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const CssUrlDependency = require("./CssUrlDependency");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/**
+ * Represents an inline `<script>...</script>` block in an HTML module. The
+ * tag's body is bundled as its own entry chunk — the same pipeline that
+ * processes `<script src>` — and the inline body is replaced with a
+ * `src` attribute pointing at the emitted chunk URL.
+ */
+class HtmlInlineScriptDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of HtmlInlineScriptDependency.
+	 * @param {string} request virtual request resolving to the inline JS (data URI)
+	 * @param {number} insertPos position right after `<script` where ` src="…"` is inserted
+	 * @param {Range} contentRange range of the inline JS body (between `<script>` and `</script>`)
+	 * @param {string} entryName name of the entry the inline JS is bundled into
+	 * @param {string=} category dependency category used for resolving and grouping
+	 */
+	constructor(request, insertPos, contentRange, entryName, category) {
+		super(request);
+		this.insertPos = insertPos;
+		this.contentRange = contentRange;
+		this.range = contentRange;
+		this.entryName = entryName;
+		/** @type {string} */
+		this._category = category || "commonjs";
+	}
+
+	get type() {
+		return "html inline script";
+	}
+
+	get category() {
+		return this._category;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.insertPos);
+		write(this.contentRange);
+		write(this.entryName);
+		write(this._category);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.insertPos = read();
+		this.contentRange = read();
+		this.range = this.contentRange;
+		this.entryName = read();
+		this._category = read();
+		super.deserialize(context);
+	}
+}
+
+HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const { runtimeTemplate } = templateContext;
+		const dep = /** @type {HtmlInlineScriptDependency} */ (dependency);
+		const compilation = runtimeTemplate.compilation;
+		const entrypoint = /** @type {Entrypoint | undefined} */ (
+			compilation.entrypoints.get(dep.entryName)
+		);
+
+		/** @type {string} */
+		let url = "data:,";
+
+		if (entrypoint) {
+			const chunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
+			const outputOptions = runtimeTemplate.outputOptions;
+			const filenameTemplate =
+				chunk.filenameTemplate ||
+				(chunk.canBeInitial()
+					? outputOptions.filename
+					: outputOptions.chunkFilename);
+
+			const filename = compilation.getPath(filenameTemplate, {
+				chunk,
+				contentHashType: "javascript"
+			});
+
+			url = `${CssUrlDependency.PUBLIC_PATH_AUTO}${filename}`;
+		}
+
+		// Insert ` src="…"` right after `<script` so the inline body is
+		// served from the emitted chunk instead. The browser ignores the
+		// remaining inline body once `src` is present, but we still clear
+		// it below so the unprocessed JS doesn't ride along.
+		source.insert(dep.insertPos, ` src="${url}"`);
+		source.replace(dep.contentRange[0], dep.contentRange[1] - 1, "");
+	}
+};
+
+makeSerializable(
+	HtmlInlineScriptDependency,
+	"webpack/lib/dependencies/HtmlInlineScriptDependency"
+);
+
+module.exports = HtmlInlineScriptDependency;